Newtonsoft.Json 的高级用法

Ø  简介

接着前一篇http://www.cnblogs.com/abeam/p/8295765.html，继续研究 Newtonsoft.Json 的一些高级用法。主要包括：

1.   JSON 格式化

2.   忽略指定成员

3.   忽略默认值成员

4.   忽略空值(null)成员

5.   驼峰命名序列化成员

6.   日期类型格式化

7.   解决序列化对象循环引用

8.   使用 JsonConverter 自定义成员转换

9.   使用 DefaultContractResolver（契约分解器）指定序列化成员

10.  使用 JsonSerializer 对象序列化与反序列化

Ø  首先，准备数据

Goods[] goods = new Goods[]

{

new Goods()

{

GoodsId = 1,

GoodsName = "联想ThinkPad无线鼠标",

//Price = 125.00m,

//IsQuota = true,

Attributes = new Goods.Attribute[]

{

new Goods.Attribute() { Name = "品牌", Value = "Lenovo/联想" },

new Goods.Attribute() { Name = "颜色", Value = "黑色" }

},

Status = Status.Online

}

};

1.   JSON 格式化（可以采用以下2种方式）

1)   简单格式化（推荐）

string jsonStr1_1_1 = JsonConvert.SerializeObject(goods, Newtonsoft.Json.Formatting.Indented);

结果：

[

{

"GoodsName": "联想ThinkPad无线鼠标",

"IsQuota": true,

"Status": "Online"

}

]

2)   使用 Newtonsoft.Json.JsonTextWriter 格式化

JsonSerializer serializer1 = new JsonSerializer();

using (StringWriter textWriter = new StringWriter())

{

using (JsonTextWriter jsonWriter = new JsonTextWriter(textWriter))

{

jsonWriter.Formatting = Newtonsoft.Json.Formatting.Indented;    //默认为Formatting.None

jsonWriter.Indentation = 4;     //缩进字符数，默认为2

jsonWriter.IndentChar = ' ';    //缩进字符，默认为' '

serializer1.Serialize(jsonWriter, goods);

}

string jsonStr1_2_1 = textWriter.ToString();

}

结果：

[

{

"GoodsName": "联想ThinkPad无线鼠标",

"IsQuota": true,

"Status": "Online"

}

]

2.   忽略指定成员

忽略指定序列化成员使用 JsonIgnore 特性，例如（修改 Goods）：

/// <summary>

/// 商品名称

/// </summary>

[JsonIgnore]

public string GoodsName { get; set; }

1)   序列化

string jsonStr2_1 = JsonConvert.SerializeObject(goods);

结果：[{"IsQuota":true,"Status":"Online"}]

2)   反序列化

string jsonStr2_2 = "[{\"GoodsName\": \"联想ThinkPad无线鼠标\",\"IsQuota\":true,\"Status\":\"Online\"}]";

Goods[] jsonObj2_1 = JsonConvert.DeserializeObject<Goods[]>(jsonStr2_2);

结果：

3.   忽略默认值成员（忽略 GoodsId 和 Price 这两个默认值）

可以采用两种方式实现：

1. 使用 JsonSerializerSettings 对象；

2. 成员标记 JsonProperty 特性并指定 DefaultValueHandling 属性。

下面演示第一种实现方式：

1)   加入 DefaultValue 特性（修改 goods）

/// <summary>

/// 价格

/// </summary>

[System.ComponentModel.DefaultValue(125.00)]

public decimal Price { get; set; }

2)   创建 JsonSerializerSettings 对象

goods[0].GoodsId = 0;   //int 类型的本身默认值（0）

goods[0].Price = 125;   //加了 System.ComponentModel.DefaultValue 特性的默认值（125）

var settings1 = new JsonSerializerSettings();

settings1.DefaultValueHandling = DefaultValueHandling.Ignore;   //默认为Include

3)   序列化

string jsonStr3_1 = JsonConvert.SerializeObject(goods, settings1);

结果：[{"GoodsName":"联想ThinkPad无线鼠标","IsQuota":true,"Status":"Online"}]

4)   反序列化

string jsonStr3_2 = "[{\"GoodsId\":0,\"GoodsName\":\"联想ThinkPad无线鼠标\",\"Price\":125,\"IsQuota\":true,\"Status\":\"Online\"}]";

Goods[] jsonObj3_1 = JsonConvert.DeserializeObject<Goods[]>(jsonStr3_2, settings1);

结果：

4.   忽略空值(null)成员

可以采用两种方式实现：

1. 使用 JsonSerializerSettings 对象；

2. 成员标记 JsonProperty 特性并指定 NullValueHandling 属性。

下面演示第一种实现方式：

goods[0].GoodsName = null;

var settings2 = new JsonSerializerSettings();

settings2.NullValueHandling = NullValueHandling.Ignore; //默认为Include

1)   序列化

string jsonStr4_1 = JsonConvert.SerializeObject(goods, settings2);

结果：[{"GoodsId":0,"Price":125.0,"IsQuota":true,"Status":"Online"}]

5.   驼峰命名序列化成员

var settings3 = new JsonSerializerSettings();

settings3.ContractResolver = new CamelCasePropertyNamesContractResolver();

1)   序列化

string jsonStr5_1 = JsonConvert.SerializeObject(goods, settings3);

结果：[{"goodsId":0,"price":125.0,"isQuota":true,"status":"Online"}]

6.   日期类型格式化

日期类型默认情况下，会序列化为一个带有“T”字符的日期字符串，比如：2018-04-24T17:58:26.0096087+08:00，可以采用两种方式对日期类型格式化，例如（修改 Goods）：

/// <summary>

/// 创建时间

/// </summary>

public DateTime CreateTime { get;set;}

goods[0].CreateTime = DateTime.Now; //2018/4/24 17:58:26

1)   默认序列化

string jsonStr6_1 = JsonConvert.SerializeObject(goods);

结果：[{"GoodsId":0,"Price":125.0,"IsQuota":true,"Status":"Online","CreateTime":"2018-04-24T17:58:26.0096087+08:00"}]

2)   使用 JsonSerializerSettings 对象格式化

var settings4 = new JsonSerializerSettings();

settings4.DateFormatString = "yyy-MM-dd";   //默认为：yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK

string jsonStr6_2 = JsonConvert.SerializeObject(goods, settings4);

结果：[{"GoodsId":0,"Price":125.0,"IsQuota":true,"Status":"Online","CreateTime":"2018-04-24"}]

3)   使用 IsoDateTimeConverter 对象格式化

var dateTimeConverter1 = new IsoDateTimeConverter();

dateTimeConverter1.DateTimeFormat = "yyy-MM-dd HH:mm:ss fff";   //默认为""

string jsonStr6_3 = JsonConvert.SerializeObject(goods, dateTimeConverter1);

结果：[{"GoodsId":0,"Price":125.0,"IsQuota":true,"Status":"Online","CreateTime":"2018-04-24 17:58:26 009"}]

4)   也可以在日期类型成员指定 JsonConverter 特性，例如：

/// <summary>

/// 创建时间

/// </summary>

[JsonConverter(typeof(Newtonsoft.Json.Converters.IsoDateTimeConverter))]

public DateTime CreateTime { get;set;}

7.   解决序列化对象循环引用

处理循环引用使用 JsonSerializerSettings 对象，并设置 ReferenceLoopHandling 属性，该属性是一个枚举类型，解释如下：

Error	默认值，发生循环引用时将抛出序列化异常：Newtonsoft.Json.JsonSerializationException
Ignore	忽略循环引用的成员
Serialize	继续序列化，不管是否存在循环引用，指定该值将抛出溢出异常：System.StackOverflowException（感觉这个值没什么用？）

下面模拟循环引用场景（修改 Goods）：

/// <summary>

/// 订单明细

/// </summary>

public OrdersDetail OrdersDetail { get; set; }

/// <summary>

/// 订单明细

/// </summary>

public class OrdersDetail

{

/// <summary>

/// 商品集合

/// </summary>

public Goods[] Goods { get; set; }

}

OrdersDetail od = new OrdersDetail() { Goods = goods };

goods[0].OrdersDetail = od;

1)   序列化

string jsonStr7_1 = JsonConvert.SerializeObject(goods); //将抛出 JsonSerializationException 异常

2)   忽略循环引用

var settings5 = new JsonSerializerSettings();

settings5.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

string jsonStr7_2 = JsonConvert.SerializeObject(goods, settings5);

结果：[{"GoodsId":0,"Price":125.0,"IsQuota":true,"Status":"Online","CreateTime":"2018-04-25T09:57:52.8628936+08:00","OrdersDetail":{}}]

8.   使用 JsonConverter 自定义成员转换

自定义成员转换使用 JsonConverter 类，该类是一个抽象类，实现 WriteJson()、ReadJson() 方法完成自定义序列化和反序列化。下面以 IsQuota 属性为例，自定义 Boolean 类型的序列化和反序列化操作。

1)   首先定义个 BoolConvert 类，继承于 Newtonsoft.Json.JsonConverter 类

/// <summary>

/// 自定义 Boolean 类型转换。

/// </summary>

public class BoolConvert : JsonConverter

{

private static readonly string[] _values = { "是", "否" };

public override bool CanConvert(Type objectType)

{

return true;

}

//序列化时被调用

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

{

if (value == null)

writer.WriteNull();             //输出：null

else if ((bool)value)

writer.WriteValue(_values[0]);  //输出：是

else

writer.WriteValue(_values[1]);  //输出：否

}

//反序列化时被调用

public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

{

//反序列化成员是否为 null 值

if (reader.TokenType == JsonToken.Null)

{

if (!IsNullableType(objectType))

throw new Exception("序列化成员不能为 null 值");

return null;

}

else if (reader.TokenType == JsonToken.String)  //为字符型，应该是“是|否”

{

string val = reader.Value.ToString();

if (val == _values[0])

return true;

else if (val == _values[1])

return false;

}

else if (reader.TokenType == JsonToken.Integer) //为 int 型，应该是：0|1

{

return Convert.ToInt32(reader.Value) != 0;  //非零即真

}

throw new Exception("反序列化不支持的 boolean 类型");

}

//判断是否为可空类型

private bool IsNullableType(Type type)

{

if (type == null)

throw new ArgumentNullException("type");

return type.BaseType.FullName == "System.ValueType" && type.GetGenericTypeDefinition() == typeof(Nullable<>);

}

}

2)   修改 Goods 类，添加 JsonConverter 特性。

/// <summary>

/// 是否限购

/// </summary>

[JsonConverter(typeof(BoolConvert))]

public bool IsQuota { get; set; }

3)   序列化

goods[0].IsQuota = true;

string jsonStr8_1 = JsonConvert.SerializeObject(goods);

结果：[{"GoodsId":1,"Price":0.0,"IsQuota":"是","Status":"Online","CreateTime":"0001-01-01T00:00:00","OrdersDetail":null}]

4)   反序列化（字符型）

string jsonStr8_2 = "[{\"IsQuota\":\"是\"}]";

Goods[] jsonObj8_1 = JsonConvert.DeserializeObject<Goods[]>(jsonStr8_2);

结果：

5)   反序列化（int 型）

string jsonStr8_3 = "[{\"IsQuota\":1}]";

Goods[] jsonObj8_2 = JsonConvert.DeserializeObject<Goods[]>(jsonStr8_3);

结果：

9.   使用 DefaultContractResolver（契约分解器）指定序列化成员

我们可以从 DefaultContractResolver 类派生一个自定义成员分解器类，重写 CreateProperties() 方法完成对每个序列化成员的操作，首先新建一个“成员契约解析器”类，例如：

/// <summary>

/// 成员契约解析器。

/// </summary>

public class MemberContractResolver : DefaultContractResolver

{

public string[] Props { get; set; }

public bool IsRetain { get; set; }

/// <summary>

/// 构造方法。

/// </summary>

/// <param name="props">指定的成员名称数组。</param>

/// <param name="isRetain">是否保留指定成员，true:保留；false:不保留。</param>

public MemberContractResolver(string[] props, bool isRetain)

{

this.Props = props;

this.IsRetain = isRetain;

}

//创建 JsonProperty 集合

protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)

{

List<JsonProperty> list = base.CreateProperties(type, memberSerialization) as List<JsonProperty>;

//顺便设置下日期格式化

IsoDateTimeConverter dtConverter = new IsoDateTimeConverter() { DateTimeFormat = "yyyy-dd-MM HH:mm:dd" };

list.ForEach(o =>

{

if (o.PropertyType == typeof(DateTime))

o.Converter = dtConverter;

});

//输出包含或不包含的指定的成员

if (this.IsRetain)

return list.Where(o => Props.Contains(o.PropertyName)).ToList();

else

return list.Where(o => !Props.Contains(o.PropertyName)).ToList();

}

}

1)   序列化包含指定成员

JsonSerializerSettings serializer6 = new JsonSerializerSettings();

serializer6.ContractResolver = new MemberContractResolver(new string[] { "GoodsName" }, true);

string jsonStr9_1 = JsonConvert.SerializeObject(goods, serializer6);

结果：[{"GoodsName":null}]

2)   序列化不包含指定成员

JsonSerializerSettings serializer7 = new JsonSerializerSettings();

serializer7.ContractResolver = new MemberContractResolver(new string[] { "GoodsName" }, false);

string jsonStr9_2 = JsonConvert.SerializeObject(goods, serializer7);

结果：[{"GoodsId":0,"Price":125.0,"IsQuota":false,"Status":"Online","CreateTime":"2018-25-04 15:35:25","OrdersDetail":null}]

10.  使用 JsonSerializer 对象序列化与反序列化

序列化与反序列化除了使用 JsonConvert 这个静态类的 SerializeObject()、DeserializeObject() 方法，还可以使用 JsonSerializer 对象的 Serialize()、Deserialize() 方法，不过这两个方法用起来比较麻烦，所有不建议使用，知道下就好了。

序列化与反序列化：

JsonSerializer serializer2 = new JsonSerializer();

using (StringWriter textWriter = new StringWriter())

{

using (JsonTextWriter jsonWriter = new JsonTextWriter(textWriter))

{

//这里可以使用 JsonTextWriter 对象进行序列化相关设置

serializer2.Serialize(jsonWriter, goods);

}

string jsonStr10_1 = textWriter.ToString();

using (TextReader textReader = new StringReader(jsonStr10_1))

{

using (JsonTextReader jsonTextReader = new JsonTextReader(textReader))

{

//这里可以使用 JsonTextReader 对象进行反序列化相关设置

object obj = serializer2.Deserialize(jsonTextReader);

}

}

}

序列化：

[{"GoodsId":0,"GoodsName":null,"Price":125.0,"IsQuota":false,"Status":"Online","CreateTime":"2018-04-25T22:10:09.4901712+08:00","OrdersDetail":null}]

反序列化：