1.介绍

  • Json.NET = Newtonsoft.json

Newtonsoft.Json - 图1

不用区分大小写

最近在做第三方对接的项目，接口返回的数据是json格式，并且每个字段都是小写的，而我们程序类中的属性是要求大写的；刚开始想到的是用JavaScriptSerializer，但是这个并不满足需求;就换了另一个NewtonsoftJson；这个反序列化的时候并不区分大小写

2.基本用法

  • 支持序列化和反序列化
  • DataTable,DataSet,Entity Framework和Entity

2.1.DataTable

  1. //序列化DataTable
  2. DataTable dt = new DataTable();
  3. dt.Columns.Add("Age", Type.GetType("System.Int32"));
  4. dt.Columns.Add("Name", Type.GetType("System.String"));
  5. dt.Columns.Add("Sex", Type.GetType("System.String"));
  6. dt.Columns.Add("IsMarry", Type.GetType("System.Boolean"));
  7. for (int i = 0; i < 4; i++)
  8. {
  9.     DataRow dr = dt.NewRow();
  10.     dr["Age"] = i + 1;
  11.     dr["Name"] = "Name" + i;
  12.     dr["Sex"] = i % 2 == 0 ? "男" : "女";
  13.     dr["IsMarry"] = i % 2 > 0 ? true : false;
  14.     dt.Rows.Add(dr);
  15. }
  16. Console.WriteLine(JsonConvert.SerializeObject(dt));

Newtonsoft.Json - 图2

  • 利用上面字符串进行反序列化
  1. string json = JsonConvert.SerializeObject(dt);
  2. dt = JsonConvert.DeserializeObject<DataTable>(json);
  3. foreach (DataRow dr in dt.Rows)
  4. {
  5.     Console.WriteLine("{0}\\t{1}\\t{2}\\t{3}\\t", dr[0], dr[1], dr[2], dr[3]);
  6. }

2.2.JsonConvert.SerializeObject

2.3.JsonConvert.DeserializeObject

3.高级用法

3.1.忽略某些属性

名称 说明
OptOut 默认值，类中所有公有成员会被序列化，如果不想被序列化，可以用特性JsonIgnore
OptIn 默认情况下，所有的成员不会被序列化，类中的成员只有标有特性JsonProperty的才会被序列化，当类的成员很多，但客户端仅仅需要一部分数据时，很有用

3.1.1.OptOut:类中所有公有成员会被序列化

  • 仅需要姓名属性
  1. [JsonObject(MemberSerialization.OptIn)]
  2. public class Person
  3. {
  4.     public int Age { get; set; }
  5.     [JsonProperty]
  6.     public string Name { get; set; }
  7.     public string Sex { get; set; }
  8.     public bool IsMarry { get; set; }
  9.     public DateTime Birthday { get; set; }
  10. }

2.1.2.OptIn:所有的成员不会被序列化

  • 不需要是否结婚属性
  1. [JsonObject(MemberSerialization.OptOut)]
  2. public class Person
  3. {
  4.     public int Age { get; set; }
  5.     public string Name { get; set; }
  6.     public string Sex { get; set; }
  7.     [JsonIgnore]
  8.     public bool IsMarry { get; set; }
  9.     public DateTime Birthday { get; set; }
  10. }

3.2.默认值的处理

序列化时想忽略默认值属性可以通过JsonSerializerSettings.DefaultValueHandling来确定，该值为枚举值

枚举值 说明
DefaultValueHandling.Ignore 序列化和反序列化时，忽略默认值
DefaultValueHandling.Include 序列化和反序列化时，包含默认值 
  1. [DefaultValue(10)]
  2. public int Age { get; set; }
  4. Person p = new Person
  5. {
  6.     Age = 10,
  7.     Name = "张三丰",
  8.     Sex = "男",
  9.     IsMarry = false,
  10.     Birthday = new DateTime(1991, 1, 2)
  11. };
  12. JsonSerializerSettings jsetting = new JsonSerializerSettings();
  13. jsetting.DefaultValueHandling = DefaultValueHandling.Ignore;
  14. Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

Newtonsoft.Json - 图3

3.3.空值的处理

序列化时需要忽略值为NULL的属性，可以通过JsonSerializerSettings.NullValueHandling来确定，另外通过JsonSerializerSettings设置属性是对序列化过程中所有属性生效的，想单独对某一个属性生效可以使用JsonProperty，下面将分别展示两个方式

  • JsonSerializerSettings
  1. Person p = new Person
  2. {
  3.     room = null,
  4.     Age = 10,
  5.     Name = "张三丰",
  6.     Sex = "男",
  7.     IsMarry = false,
  8.     Birthday = new DateTime(1991, 1, 2)
  9. };
  10. JsonSerializerSettings jsetting = new JsonSerializerSettings();
  11. jsetting.NullValueHandling = NullValueHandling.Ignore;
  12. Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

Newtonsoft.Json - 图4

  • JsonProperty

Newtonsoft.Json - 图5

通过JsonProperty属性设置的方法，可以实现某一属性特别处理的需求，如默认值处理，空值处理，自定义属性名处理，格式化处理。上面空值处理实现

  1. [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
  2. public Room room { get; set; }

3.4.支持非公共成员

序列化时默认都是处理公共成员，如果需要处理非公共成员，就要在该成员上加特性[JsonProperty]

  1. [JsonProperty]
  2. private int Height { get; set; }

3.5.日期处理

对于Dateime类型日期的格式化就比较麻烦了，系统自带的会格式化成iso日期标准”Birthday”:”1991-01-02T00:00:00，但是实际使用过程中大多数使用的可能是yyyy-MM-dd或者yyyy-MM-dd HH:mm:ss两种格式的日期，解决办法是可以将DateTime类型改成string类型自己格式化好，然后再序列化。如果不想修改代码，可以采用下面方案实现。

  • Json.Net提供了IsoDateTimeConverter日期转换这个类，可以通过JsnConverter实现相应的日期转换
  1. [JsonConverter(typeof(IsoDateTimeConverter))]
  2. public DateTime Birthday { get; set; }
  • 但是IsoDateTimeConverter日期格式不是我们想要的，我们可以继承该类实现自己的日期
  1. public class ChinaDateTimeConverter : DateTimeConverterBase
  2. {
  3.     private static IsoDateTimeConverter dtConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd" };
  4.     public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
  5.     {
  6.         return dtConverter.ReadJson(reader, objectType, existingValue, serializer);
  7.     }
  8.     public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
  9.     {
  10.         dtConverter.WriteJson(writer, value, serializer);
  11.     }
  12. }
  • 自己实现了一个yyyy-MM-dd格式化转换类，可以看到只是初始化IsoDateTimeConverter时给的日期格式为yyyy-MM-dd即可，下面看下效果
  1. [JsonConverter(typeof(ChinaDateTimeConverter))]
  2. public DateTime Birthday { get; set; }

Newtonsoft.Json - 图6

3.6.自定义序列化的字段名称

  • 实体中定义的属性名可能不是自己想要的名称，但是又不能更改实体定义，这个时候可以自定义序列化字段名称。
  1. [JsonProperty(PropertyName = "CName")]
  2. public string Name { get; set; }

例子

  1. public class Student {
  2.     [JsonProperty(PropertyName ="ID")]
  3.     public int id;
  4.     [JsonProperty(PropertyName ="XName")]
  5.     public string name;
  6. }

  • 序列化 Newtonsoft.Json - 图7

  • 反序列化： Newtonsoft.Json - 图8

3.7.动态决定属性是否序列化

  • 根据某些场景，可能A场景输出A，B，C三个属性，B场景输出E，F属性。虽然实际中不一定存在这种需求，但是json.net依然可以支持该特性。

  • 继承默认的DefaultContractResolver类，传入需要输出的属性

  • 重写修改了一下，大多数情况下应该是要排除的字段少于要保留的字段, 为了方便书写这里修改了构造函数加入retain表示props是需要保留的字段还是要排除的字段

  1. public class LimitPropsContractResolver : DefaultContractResolver
  2. {
  3.     string[] props = null;
  4.     bool retain;
  5.     /// <summary>
  6.     /// 构造函数
  7.     /// </summary>
  8.     /// <param name="props">传入的属性数组</param>
  9.     /// <param name="retain">true:表示`props`是需要保留的字段`false`：表示`props`是要排除的字段</param>
  10.     public LimitPropsContractResolver(string[] props, bool retain = true)
  11.     {
  12.         //指定要序列化属性的清单
  13.         this.props = props;
  14.         this.retain = retain;
  15.     }
  17.     protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
  18.     {
  19.         IList<JsonProperty> list = base.CreateProperties(type, memberSerialization); //只保留清单有列出的属性
  20.         return list.Where(p =>
  21.         {
  22.             if (retain)
  23.             {
  24.                 return props.Contains(p.PropertyName);
  25.             }
  26.             else
  27.             {
  28.                 return !props.Contains(p.PropertyName);
  29.             }
  30.         }).ToList();
  31.     }
  32. }
  1. public int Age { get; set; }
  2. [JsonIgnore]
  3. public bool IsMarry { get; set; }
  4. public string Sex { get; set; }
  6. JsonSerializerSettings jsetting = new JsonSerializerSettings();
  7. jsetting.ContractResolver = new LimitPropsContractResolver(new string[] { "Age", "IsMarry" });
  8. Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));
  • 使用自定义的解析类，只输出Age、IsMarry两个属性，看下最终结果。只输出了Age属性，为什么IsMarry属性没有输出呢，因为标注了[JsonIgnore]

Newtonsoft.Json - 图9

  • 看到上面的结果想要实现pc端序列化一部分，手机端序列化另一部分就很简单了吧，我们改下代码实现一下
  1. string[] propNames = null;
  2. if (p.Age > 10)
  3. {
  4.     propNames = new string[] { "Age", "IsMarry" };
  5. }
  6. else
  7. {
  8.     propNames = new string[] { "Age", "Sex" };
  9. }
  10. jsetting.ContractResolver = new LimitPropsContractResolver(propNames);
  11. Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

3.8.枚举值的自定义格式化问题

默认情况下对于实体里面的枚举类型系统是格式化成改枚举对应的整型数值，那如果需要格式化成枚举对应的字符怎么处理呢？Newtonsoft.Json也帮我们想到了这点，下面看实例

  1. public enum NotifyType
  2. {
  3.     /// <summary>
  4.     /// Emil发送
  5.     /// </summary>
  6.     Mail = 0,
  7.     /// <summary>
  8.     /// 短信发送
  9.     /// </summary>
  10.     SMS = 1
  11. }
  12. public class TestEnmu
  13. {
  14.     /// <summary>
  15.     /// 消息发送类型
  16.     /// </summary>    
  17.     public NotifyType Type { get; set; }
  18. }
  19. JsonConvert.SerializeObject(new TestEnmu());
  • 输出结果：

Newtonsoft.Json - 图10

  • 现在改造一下，输出”Type”:”Mail”
  1. public class TestEnmu
  2. {
  3.     /// <summary>
  4.     ///消息发送类型
  5.     /// </summary>
  6.     [JsonConverter(typeof(StringEnumConverter))]
  7.     public NotifyType Type { get; set; }
  8. }

　　其它的都不变，在Type属性上加上了JsonConverter(typeof(StringEnumConverter))表示将枚举值转换成对应的字符串，而StringEnumConverter是Newtonsoft.Json内置的转换类型，最终输出结果

Newtonsoft.Json - 图11

3.9.自定义类型转换

默认情况下对于实体里面的Boolean系统是格式化成true或者false，对于true转成”是” false转成”否”这种需求改怎么实现了？我们可以自定义类型转换实现该需求，下面看实例

  1. public class BoolConvert : JsonConverter
  2. {
  3.     private string[] arrBString { get; set; }
  5.     public BoolConvert()
  6.     {
  7.         arrBString = "是,否".Split(',');
  8.     }
  10.     /// <summary>
  11.     /// 构造函数
  12.     /// </summary>
  13.     /// <param name="BooleanString">将`bool`值转换成的字符串值</param>
  14.     public BoolConvert(string BooleanString)
  15.     {
  16.         if (string.IsNullOrEmpty(BooleanString))
  17.         {
  18.             throw new ArgumentNullException();
  19.         }
  20.         arrBString = BooleanString.Split(',');
  21.         if (arrBString.Length != 2)
  22.         {
  23.             throw new ArgumentException("BooleanString格式不符合规定");
  24.         }
  25.     }
  27.     public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
  28.     {
  29.         bool isNullable = IsNullableType(objectType);
  30.         Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;
  31.         if (reader.TokenType == JsonToken.Null)
  32.         {
  33.             if (!IsNullableType(objectType))
  34.             {
  35.                 throw new Exception(string.Format("不能转换null value to {0}.", objectType));
  36.             }
  37.             return null;
  38.         }
  39.         try
  40.         {
  41.             if (reader.TokenType == JsonToken.String)
  42.             {
  43.                 string boolText = reader.Value.ToString();
  44.                 if (boolText.Equals(arrBString[0], StringComparison.OrdinalIgnoreCase))
  45.                 {
  46.                     return true;
  47.                 }
  48.                 else if (boolText.Equals(arrBString[1], StringComparison.OrdinalIgnoreCase))
  49.                 {
  50.                     return false;
  51.                 }
  52.             }
  53.             if (reader.TokenType == JsonToken.Integer)
  54.             {
  55.                 return Convert.ToInt32(reader.Value) == 1;
  56.             }
  57.         }
  58.         catch (Exception ex)
  59.         {
  60.             throw new Exception(string.Format("Error converting value {0} to type '{1}'", reader.Value, objectType));
  61.         }
  62.         throw new Exception(string.Format("Unexpected token {0} when parsing enum", reader.TokenType));
  63.     }
  65.     /// <summary>
  66.     /// 判断是否为`Bool`类型
  67.     /// </summary>
  68.     /// <param name="objectType">类型</param>
  69.     /// <returns>为`bool`类型则可以进行转换</returns>
  70.     public override bool CanConvert(Type objectType)
  71.     {
  72.         return true;
  73.     }
  75.     public bool IsNullableType(Type t)
  76.     {
  77.         if (t == null)
  78.         {
  79.             throw new ArgumentNullException("t");
  80.         }
  81.         return (t.BaseType.FullName == "System.ValueType" && t.GetGenericTypeDefinition() == typeof(Nullable<>));
  82.     }
  84.     public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
  85.     {
  86.         if (value == null)
  87.         {
  88.             writer.WriteNull(); return;
  89.         }
  90.         bool bValue = (bool)value; if (bValue)
  91.         {
  92.             writer.WriteValue(arrBString[0]);
  93.         }
  94.         else
  95.         {
  96.             writer.WriteValue(arrBString[1]);
  97.         }
  98.     }
  99. }

　　自定义了BoolConvert类型，继承自JsonConverter。构造函数参数BooleanString可以让我们自定义将true false转换成相应字符串。下面看实体里面怎么使用这个自定义转换类型

  1. public class Person
  2. {
  3.     [JsonConverter(typeof(BoolConvert))]
  4.     public bool IsMarry { get; set; }
  5. }

Newtonsoft.Json - 图12

相应的有什么个性化的转换需求，都可以使用自定义转换类型的方式实现。

3.10.全局序列化设置

文章开头提出了Null值字段怎么不返回的问题，相应的在高级用法也给出了相应的解决方案使用jsetting.NullValueHandling = NullValueHandling.Ignore;来设置不返回空值。这样有个麻烦的地方，每个不想返回空值的序列化都需设置一下。可以对序列化设置一些默认值方式么？下面将解答

  1. Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();
  2. JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() => {//日期类型默认格式化处理
  3.     setting.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
  4.     setting.DateFormatString = "yyyy-MM-dd HH:mm:ss"; //空值处理
  5.     setting.NullValueHandling = NullValueHandling.Ignore; //高级用法九中的`Bool`类型转换设置
  6.     setting.Converters.Add(new BoolConvert("是，否")); 
  7.     return setting;
  8. });

这样设置以后，以后使用序列化的地方就不需要单独设置了，个人最喜欢设置的是空值处理这一块。

3.11.自定义字段顺序

看文档是用JsonProperty(Order = n)特性来定义顺序, 想让两个字段排在前2位, 但是用-2, -1和-1, -2试了都不可以, 最后找到答案, 原来默认不定义该特性时, 顺序是-1, 所以要比-1小才可以.

99.参考资料