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}]

反序列化：