json取值_.NETCore3.1中的Json互操作最全解读收藏级

作者：mobiledu2402851203 | 来源：互联网 | 2023-09-13 19:21

前言本文比较长，我建议大家先点赞、收藏后慢慢阅读，点赞再看，形成习惯！我很高兴,.NETCore终于来到了3.1LTS版本&

前言

本文比较长&＃xff0c;我建议大家先点赞、收藏后慢慢阅读&＃xff0c;点赞再看&＃xff0c;形成习惯&＃xff01;

我很高兴,.NETCore终于来到了3.1LTS版本&＃xff0c;并且将支持3年&＃xff0c;我们也准备让部分业务迁移到3.1上面&＃xff0c;不过很快我们就遇到了新的问题&＃xff0c;就是对于Json序列化的选择&＃xff1b;我本着清真的原则&＃xff0c;既然选择迁移到3.1&＃xff0c;一切都应该用官方标准或者建议方案。所以我们信心满满的选择了System.Text.Json。本文将会全面介绍System.Text.Json 和 Newtonsoft.Json 的相同和异同之处&＃xff0c;方便需要的同学做迁移使用&＃xff0c;对未来&＃xff0c;我们保持期待。

文档比较

几个重要的对象

在 System.Text.Json 中&＃xff0c;有几个重量级的对象&＃xff0c;所有的JSON互操作&＃xff0c;都是围绕这几个对象进行&＃xff0c;只要理解了他们各自的用途用法&＃xff0c;就基本上掌握了JSON和实体对象的互操作。

JsonDocument

提供用于检查 JSON 值的结构内容&＃xff0c;而不自动实例化数据值的机制。JsonDocument 有一个属性 RootElement&＃xff0c;提供对JSON文档根元素的访问&＃xff0c;RootElement是一个JsonElement对象。

JsonElement

提供对JSON值的访问&＃xff0c;在System.Text.Json 中&＃xff0c;大到一个对象、数组&＃xff0c;小到一个属性、值&＃xff0c;都可以通过 JsonElement 进行互操作

JsonProperty

JSON中最小的单元&＃xff0c;提供对属性、值的访问

JsonSerializer

提供JSON互操作的静态类&＃xff0c;提供了一系列 Serializer/Deserialize 的互操作的方法&＃xff0c;其中还有一些异步/流式操作方法。

JsonSerializerOptions

与上面的 JsonSerializer 配合使用&＃xff0c;提供自定义的个性化互操作选项&＃xff0c;包括命名、枚举转换、字符转义、注释规则、自定义转换器等等操作选项。

Utf8JsonWriter/Utf8JsonReader

这两个对象是整个 System.Text.Json 的核心对象&＃xff0c;所有的JSON互操作几乎都是通过这两个对象进行&＃xff0c;他们提供的高性能的底层读写操作。

初始化一个简单的 JSON 对象

在 System.Text.Json 中&＃xff0c;并未提供像 JToken 那样非常便捷的创建对象的操作&＃xff0c;想要创建一个 JSON 对象&＃xff0c;其过程是比较麻烦的&＃xff0c;请看下面的代码&＃xff0c;进行对比

// Newtonsoft.Json.Linq;

JToken root &＃61; new JObject();

root["Name"] &＃61; "Ron";

root["Money"] &＃61; 4.5;

root["Age"] &＃61; 30;

string jsonText &＃61; root.ToString();

// System.Text.Json

string json &＃61; string.Empty;

using (MemoryStream ms &＃61; new MemoryStream())

{

using (Utf8JsonWriter writer &＃61; new Utf8JsonWriter(ms))

{

writer.WriteStartObject();

writer.WriteString("Name", "Ron");

writer.WriteNumber("Money", 4.5);

writer.WriteNumber("Age", 30);

writer.WriteEndObject();

writer.Flush();

}

json &＃61; Encoding.UTF8.GetString(ms.ToArray());

}

System.Text.Json 的操作便利性在这方面目前处于一个比较弱的状态&＃xff0c;不过&＃xff0c;从这里也可以看出&＃xff0c;可能官方并不希望我们去直接操作 JSON 源&＃xff0c;而是通过操作实体对象以达到操作 JSON 的目的&＃xff0c;也可能对互操作是性能比较自信的表现吧。

封装和加载

在对JSON文档进行包装的用法

var json &＃61; "{\"name\":\"Ron\",\"money\":4.5}";

var jDoc &＃61; System.Text.Json.JsonDocument.Parse(json);

var jToken &＃61; Newtonsoft.Json.Linq.JToken.Parse(json);

我发现MS这帮人很喜欢使用 Document 这个词,包括XmlDocument/XDocument等等。

查找元素(对象)

var json &＃61; "{\"name\":\"Ron\",\"money\":4.5}";

var jDoc &＃61; System.Text.Json.JsonDocument.Parse(json);

var obj &＃61; jDoc.RootElement[0];// 这里会报错&＃xff0c;索引仅支持 Array 类型的JSON文档

var jToken &＃61; Newtonsoft.Json.Linq.JToken.Parse(json);

var name &＃61; jToken["name"];

你看&＃xff0c;到查找元素环节就体现出差异了&＃xff0c;JsonDocuemnt 索引仅支持 Array 类型的JSON文档&＃xff0c;而 JToken 则支持 object 类型的索引(充满想象)&＃xff0c;用户体验高下立判。那我们不禁要提问了&＃xff0c;如何在 JsonDocument 中查找元素&＃xff1f;答案如下。

var json &＃61; "{\"name\":\"Ron\",\"money\":4.5}";

var jDoc &＃61; System.Text.Json.JsonDocument.Parse(json);

var enumerate &＃61; jDoc.RootElement.EnumerateObject();

while (enumerate.MoveNext())

{

if (enumerate.Current.Name &＃61;&＃61; "name")

Console.WriteLine("{0}:{1}", enumerate.Current.Name, enumerate.Current.Value);

}

从上面的代码来看&＃xff0c;JsonElement 存在两个迭代器&＃xff0c;分别是EnumerateArray和EnumerateObject&＃xff1b;通过迭代器&＃xff0c;你可以实现查找元素的需求。你看&＃xff0c;MS关上了一扇门&＃xff0c;然后又为了打开了一扇窗&＃xff0c;还是很人性化的了。在System.Text.Json中&＃xff0c;一切对象都是Element&＃xff0c;Object/Array/Property&＃xff0c;都是Element&＃xff0c;这个概念和XML一致&＃xff0c;但是和Newtonsoft.Json不同&＃xff0c;这是需要注意的地方。

你也可以选择不迭代&＃xff0c;直接获取对象的属性&＃xff0c;比如使用下面的方法

var json &＃61; "{\"name\":\"Ron\",\"money\":4.5}";

var jDoc &＃61; System.Text.Json.JsonDocument.Parse(json);

var age &＃61; jDoc.RootElement.GetProperty("age");

上面这段代码将抛出异常&＃xff0c;因为属性 age 不存在&＃xff0c;通常情况下&＃xff0c;我们会立即想用一个 ContainsKey 来作一个判断&＃xff0c;但是很可惜&＃xff0c;JsonElement 并未提供该方法&＃xff0c;而是提供了一个 TryGetProperty 方法&＃xff1b;所以&＃xff0c;除非你明确知道 json 对象中的属性&＃xff0c;否则一般情况下&＃xff0c;建议使用 TryGetProperty 进行取值。

就算是这样&＃xff0c;使用 GetProperty/TryGetProperty 得到的值&＃xff0c;还是一个 JsonElement 对象&＃xff0c;并不是你期望的“值”。所以 JsonElement 很人性化的提供了各种 GetIntxx/GetString 方法&＃xff0c;但是就算如此&＃xff0c;还是可能产生意外&＃xff0c;思考下面的代码&＃xff1a;

var json &＃61; "{\"name\":\"Ron\",\"money\":4.5,\"age\":null}";

var jDoc &＃61; System.Text.Json.JsonDocument.Parse(json);

var property &＃61; jDoc.RootElement.GetProperty("age");

var age &＃61; property.GetInt32();

上面的代码&＃xff0c;最后一行将抛出异常&＃xff0c;因为你尝试从一个 null 到 int32 的类型转换&＃xff0c;怎么解决这种问题呢&＃xff0c;又回到了 JsonElement 上面来&＃xff0c;他又提供了一个对值进行检查的方法

if (property.ValueKind &＃61;&＃61; JsonValueKind.Number)

{

var age &＃61; property.GetInt32();

}

这个时候&＃xff0c;程序运行良好&＃xff0c;JsonValueKind 枚举提供了一系列的类型标识&＃xff0c;为了进一步缩小内存使用率&＃xff0c;Json团队用心良苦的将枚举值声明为&＃xff1a;byte 类型(够抠)

public enum JsonValueKind : byte

{

Undefined &＃61; 0,

Object &＃61; 1,

Array &＃61; 2,

String &＃61; 3,

Number &＃61; 4,

True &＃61; 5,

False &＃61; 6,

Null &＃61; 7

}

看到这里&＃xff0c;你是不是有点想念 Newtonsoft.Json 了呢&＃xff1f;别着急&＃xff0c;下面我给大家介绍一个宝贝 System.Json.dll。

System.Json

基本介绍

System.Json 提供了对JSON 对象序列化的基础支持&＃xff0c;但是也是有限的支持&＃xff0c;请看下图

System.Json 目前已合并到 .NETCore-3.1 中&＃xff0c;如果你希望使用他&＃xff0c;需要单独引用

Install-Package System.Json -Version 4.7.0

这个JSON互操作包提供了几个常用的操作类型&＃xff0c;从下面的操作类不难看出&＃xff0c;提供的支持是非常有限的&＃xff0c;而且效率上也不好说

System.Json.JsonArray

System.Json.JsonObject

System.Json.JsonPrimitive

System.Json.JsonValue

首先&＃xff0c;JsonObject是实现 IDictionary 接口&＃xff0c;并在内部维护一个 SortedDictionary字典&＃xff0c;所以他具备字典类的一切操作&＃xff0c;比如索引等等&＃xff0c;JsonArray 就更简单&＃xff0c;也是一样的实现 IList接口&＃xff0c;然后同样的在内部维护一个 List链表&＃xff0c;以实现数组功能&＃xff0c;对象的序列化都是通过 JsonValue 进行操作&＃xff0c;序列化的方式也是非常的简单&＃xff0c;就是对对像进行迭代&＃xff0c;唯一值得称道的地方是&＃xff0c;采用了流式处理。

使用System.Json操作上面的查找过程如下

var obj &＃61; System.Json.JsonObject.Parse("{\"name\":\"ron\"}");

if (obj.ContainsKey("age"))

{

int age &＃61; obj["age"];

}

令人遗憾的是&＃xff0c;虽然 System.Json 已经合并到 .NETCore-3.1 的路线图中&＃xff1b;但是&＃xff0c;System.Text.Json 不提供对 System.Json 的互操作性&＃xff0c;我们期待以后 System.Text.Json 也能提供 System.Json 的操作便利性。

序列化和反序列化

基本知识已经介绍完成&＃xff0c;下面我们进入 System.Text.Json 的内部世界一探究竟。

互操作

思考下面的代码

// 序列化

var user &＃61; new UserInfo { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30 };

var json &＃61; JsonSerializer.Serialize(user);

// 输出

{"Name":"Ron","Money":4.5,"Age":30}

// 反序列化

user &＃61; JsonSerializer.Deserialize(json);

目前为止&＃xff0c;上面的代码工作良好。让我们对上面的代码稍作修改&＃xff0c;将 JSON 字符串进行一个转小写的操作后再进行反序列化的操作

// 输出

{"name":"Ron","money":4.5,"age":30}

// 反序列化

user &＃61; JsonSerializer.Deserialize(json);

上面的代码可以正常运行&＃xff0c;也不会抛出异常&＃xff0c;你可以得到一个完整的 user 对象&＃xff1b;但是&＃xff0c;user对象的属性值将会丢失&＃xff01;这是因为 System.Text.Json 默认采用的是区分大小写匹配的方式&＃xff0c;为了解决这个问题&＃xff0c;我们需要引入序列化操作个性化设置&＃xff0c;请参考下面的代码&＃xff0c;启用忽略大小写的设置

// 输出

{"name":"Ron","money":4.5,"age":30}

var options &＃61; new JsonSerializerOptions()

{

PropertyNameCaseInsensitive &＃61; true

};

// 反序列化

user &＃61; JsonSerializer.Deserialize(json,options);

格式化JSON

现在你可以选择对序列化的JSON文本进行美化&＃xff0c;而不是输出上面的压缩后的JSON文本&＃xff0c;为了实现美化的效果&＃xff0c;你仅仅需要在序列化的时候加入一个 WriteIndented 设置

var options &＃61; new JsonSerializerOptions()

options.WriteIndented &＃61; true;

var user &＃61; new UserInfo { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30, Remark &＃61; "你好&＃xff0c;欢迎&＃xff01;" };

var json &＃61; JsonSerializer.Serialize(user, options);

// 输出

{

"Name": "Ron",

"Money": 4.5,

"Age": 30,

"Remark": "\u4F60\u597D\uFF0C\u6B22\u8FCE\uFF01"

}

你看&＃xff0c;就是这么简单&＃xff0c;但是你也发现了&＃xff0c;上面的 Remark 属性在序列化后&＃xff0c;中文被转义了&＃xff0c;这就是接下来要解决的问题

字符转义的问题

在默认情况下&＃xff0c;System.Text.Json 序列化程序对所有非 ASCII 字符进行转义&＃xff1b;这就是中文被转义的根本原因。但是在内部&＃xff0c;他又允许你自定义控制字符集的转义行为&＃xff0c;这个设置就是&＃xff1a;Encoder&＃xff0c;比如下面的代码&＃xff0c;对中文进行转义的例外设置&＃xff0c;需要创建一个 TextEncoderSettings 对象&＃xff0c;并将 UnicodeRanges.All 加入允许例外范围内&＃xff0c;并使用 JavascriptEncoder 根据 TextEncoderSettings创建一个 JavascriptEncoder 对象即可。

var encoderSettings &＃61; new TextEncoderSettings();

encoderSettings.AllowRanges(UnicodeRanges.All);

var options &＃61; new JsonSerializerOptions();

options.Encoder &＃61; JavascriptEncoder.Create(encoderSettings);

options.WriteIndented &＃61; true;

var user &＃61; new UserInfo { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30, Remark &＃61; "你好&＃xff0c;欢迎&＃xff01;" };

var json &＃61; JsonSerializer.Serialize(user, options);

// 输出

{

"Name": "Ron",

"Money": 4.5,

"Age": 30,

"Remark": "你好&＃xff0c;欢迎&＃xff01;"

}

还有另外一种模式&＃xff0c;可以不必设置例外而达到不转义的效果&＃xff0c;这个模式就是“非严格JSON”模式&＃xff0c;将上面的 JavascriptEncoder.Create(encoderSettings) 替换为下面的代码

options.Encoder &＃61; JavascriptEncoder.UnsafeRelaxedJsonEscaping;

序列化相关-异步/流式

System.Text.Josn 提供了一系列丰富的JSON互操作&＃xff0c;这其中包含异步和流式处理&＃xff0c;这点也是和 Newtonsoft.Json 最大的不同&＃xff0c;但不管是那种方式&＃xff0c;都要牢记&＃xff0c;最后都是通过下面的两个类来实现

System.Text.Json.Utf8JsonReader

System.Text.Json.Utf8JsonWriter

自定义 JSON 名称和值

在默认情况下&＃xff0c;输出的JSON属性名称保持和实体对象相同&＃xff0c;包括大小写的都是一致的&＃xff0c;枚举类型在默认情况下被序列化为数值类型。System.Text.JSON 提供了一系列的设置和扩展来帮助开发者实现各种自定义的需求。下面的代码可以设置默认的JSON属性名称&＃xff0c;这个设置和 Newtonsoft.Json 基本一致。

public class UserInfo

{

[JsonPropertyName("name")] public string Name { get; set; }

public decimal Money { get; set; }

public int Age { get; set; }

public string Remark { get; set; }

}

UserInfo 的属性 Name 在输出为 JSON 的时候&＃xff0c;其字段名称将为&＃xff1a;name&＃xff0c;其他属性保持大小写不变

对所有属性设置为 camel 大小写

var options &＃61; new JsonSerializerOptions

{

PropertyNamingPolicy &＃61; JsonNamingPolicy.CamelCase

};

jsonSerializer.Serialize(user, options);

自定义名称策略

比如我们的系统&＃xff0c;目前采用全小写的模式&＃xff0c;那么我可以自定义一个转换器&＃xff0c;并应用到序列化行为中。

public class LowerCaseNamingPolicy : JsonNamingPolicy

{

public override string ConvertName(string name) &＃61;> name.ToLower();

}

var options &＃61; new JsonSerializerOptions();

// 应用策略

options.PropertyNamingPolicy &＃61; new LowerCaseNamingPolicy();

var user &＃61; new UserInfo { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30};

var json &＃61; JsonSerializer.Serialize(user, options);

将枚举序列化为名称字符串而不是数值

var options &＃61; new JsonSerializerOptions();

// 添加转换器

options.Converters.Add(new JsonStringEnumConverter());

var user &＃61; new UserInfo { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30;

var json &＃61; JsonSerializer.Serialize(user, options);

排除不需要序列化的属性

在默认情况下&＃xff0c;所有公共属性将被序列化为JSON。但是&＃xff0c;如果你不想让某些属性出现在 JSON 中&＃xff0c;可以通过下面的几种方式实现属性排除

排除所有属性值为 null 属性

var options &＃61; new JsonSerializerOptions();

options.Encoder &＃61; JavascriptEncoder.UnsafeRelaxedJsonEscaping;

options.IgnoreNullValues &＃61; true;

var user &＃61; new UserInfo { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30, Remark &＃61;null};

var json &＃61; JsonSerializer.Serialize(user, options);

// 输出&＃xff0c;可以看到&＃xff0c;Remark 属性被排除

{"name":"Ron","Money":4.5,"Age":30}

排除指定标记属性

可以为某个属性应用 JsonIgnore 特性&＃xff0c;标记为不输出到 JSON

public class UserInfo

{

[JsonPropertyName("name")] public string Name { get; set; }

public decimal Money { get; set; }

[JsonIgnore]public int Age { get; set; }

public string Remark { get; set; }

}

var user &＃61; new UserInfo { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30, Remark &＃61;null};

var json &＃61; JsonSerializer.Serialize(user);

// 输出&＃xff0c;属性 Age 已被排除

{"name":"Ron","Money":4.5,"Remark":null}

排除所有只读属性

还可以选择对所有只读属性进行排查输出 JSON&＃xff0c;比如下面的代码&＃xff0c;Password 是不需要输出的&＃xff0c;那么我们只需要将 Password 设置为 getter&＃xff0c;并应用 IgnoreReadOnlyProperties &＃61; true 即可

public class UserInfo

{

[JsonPropertyName("name")] public string Name { get; set; }

public decimal Money { get; set; }

[JsonIgnore] public int Age { get; set; }

public int Password { get; }

public string Remark { get; set; }

}

var options &＃61; new JsonSerializerOptions

{

IgnoreReadOnlyProperties &＃61; true

};

var user &＃61; new UserInfo { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30, Remark &＃61; null };

var json &＃61; JsonSerializer.Serialize(user, options);

// 输出

{"name":"Ron","Money":4.5,"Remark":null}

排除派生类的属性

在某些情况下&＃xff0c;由于业务需求的不同&＃xff0c;需要实现实体对象的继承&＃xff0c;但是在输出 JSON 的时候&＃xff0c;希望只输出基类的属性&＃xff0c;而不要输出派生类型的属性&＃xff0c;以避免产生不可控制的数据泄露问题&＃xff1b;那么&＃xff0c;我们可以采用下面的序列化设置。比如下面的 UserInfoExtension 派生自 UserInfo&＃xff0c;并扩展了一个属性为身份证的属性&＃xff0c;在输出 JSON 的时候&＃xff0c;我们希望不要序列化派生类&＃xff0c;那么我们可以在 Serialize 序列化的时候&＃xff0c;指定序列化的类型为基类&＃xff1a;UserInfo&＃xff0c;即可达到隐藏派生类属性的目的。

public class UserInfo

{

[JsonPropertyName("name")] public string Name { get; set; }

public decimal Money { get; set; }

[JsonIgnore] public int Age { get; set; }

public int Password { get; }

public string Remark { get; set; }

}

public class UserInfoExtension : UserInfo

{

public string IdCard { get; set; }

}

var user &＃61; new UserInfoExtension { Name &＃61; "Ron", Money &＃61; 4.5m, Age &＃61; 30, Remark &＃61; null };

var json &＃61; JsonSerializer.Serialize(user, typeof(UserInfo));

// 输出

{"name":"Ron","Money":4.5,"Password":0,"Remark":null}

仅输出指定属性(排除属性的逆向操作)

在 Newtonsoft.Json 中&＃xff0c;我们可以通过指定 MemberSerialization 和 JsonProperty 来实现输出指定属性到 JSON 中&＃xff0c;比如下面的代码

[Newtonsoft.Json.JsonObject(Newtonsoft.Json.MemberSerialization.OptIn)]

public class UserInfo

{

[Newtonsoft.Json.JsonProperty("name")] public string Name { get; set; }

public int Age { get; set; }

}

var user &＃61; new UserInfo() { Age &＃61; 18, Name &＃61; "Ron" };

var json &＃61; Newtonsoft.Json.JsonConvert.SerializeObject(user);

// 输出

{"name":"Ron"}

不过&＃xff0c;很遗憾的告诉大家&＃xff0c;目前 System.Text.Json 不支持这种方式&＃xff1b;为此&＃xff0c;我特意去看了 corefx 的 issue&＃xff0c;我看到了下面这个反馈

现在可以方向了&＃xff0c;当 .NETCore 合并到主分支 .NET 也就是 .NET5.0 的时候&＃xff0c;官方将提供支持&＃xff0c;在此之前&＃xff0c;还是使用推荐 Newtonsoft.Json 。

在反序列化的时候&＃xff0c;允许 JSON 文本包含注释

默认情况下&＃xff0c;System.Text.JSON 不支持源JSON 文本包含注释&＃xff0c;比如下面的代码&＃xff0c;当你不使用 ReadCommentHandling &＃61; JsonCommentHandling.Skip 的设置的时候&＃xff0c;将抛出异常&＃xff0c;因为在字段 Age 的后面有注释 /* age */。

var jsonText &＃61; "{\"Name\":\"Ron\",\"Money\":4.5,\"Age\":30/* age */}";

var options &＃61; new JsonSerializerOptions

{

ReadCommentHandling &＃61; JsonCommentHandling.Skip,

AllowTrailingCommas &＃61; true,

};

var user &＃61; JsonSerializer.Deserialize(jsonText);

允许字段溢出

在接口数据出现变动时&＃xff0c;极有可能出现源 JSON 文本和实体对象属性不匹配的问题&＃xff0c;JSON 中可能会多出一些实体对象不存在的属性&＃xff0c;这种情况我们称之为“溢出”&＃xff0c;在默认情况下&＃xff0c;溢出的属性将被忽略&＃xff0c;如果希望捕获这些“溢出”的属性&＃xff0c;可以在实体对象中声明一个类型为&＃xff1a;Dictionary的属性&＃xff0c;并对其应用特性标记&＃xff1a;JsonExtensionData。

为了演示这种特殊的处理&＃xff0c;我们声明了一个实体对象 UserInfo&＃xff0c;并构造了一个 JSON 源&＃xff0c;该 JSON 源包含了一个 UserInfo 不存在的属性&＃xff1a;Money&＃xff0c;预期该 Money 属性将被反序列化到属性 ExtensionData 中。

public class UserInfo

{

public string Name { get; set; }

public int Age { get; set; }

[JsonExtensionData] public Dictionary ExtensionData { get; set; }

}

var jsonText &＃61; "{\"Name\":\"Ron\",\"Money\":4.5,\"Age\":30}";

var user &＃61; JsonSerializer.Deserialize(jsonText);

输出截图

有意思的是&＃xff0c;被特性 JsonExtensionData 标记的属性&＃xff0c;在序列化为 JSON 的时候&＃xff0c;他又会将 ExtensionData 的字典都序列化为单个 JSON 的属性&＃xff0c;这里不再演示&＃xff0c;留给大家去体验。

转换器

System.Text.Json 内置了各种丰富的类型转换器&＃xff0c;这些默认的转换器在程序初始化 JsonSerializerOptions 的时候就默认加载&＃xff0c;在 JsonSerializerOptions 内部&＃xff0c;维护着一个私有静态成员 s_defaultSimpleConverters&＃xff0c;同时还有一个公有属性 Converters &＃xff0c;Converters 属性在 JsonSerializerOptions 的构造函数中被初始化&＃xff1b;从下面的代码中可以看到&＃xff0c;默认转换器集合和公有转换器集是相互独立的&＃xff0c;System.Text.Json 允许开发人员通过 Converters 添加自定义的转换器。

public sealed partial class JsonSerializerOptions

{

// The global list of built-in simple converters.

private static readonly Dictionary s_defaultSimpleConverters &＃61; GetDefaultSimpleConverters();

// The global list of built-in converters that override CanConvert().

private static readonly List s_defaultFactoryConverters &＃61; GetDefaultConverters();

// The cached converters (custom or built-in).

private readonly ConcurrentDictionary _converters &＃61; new ConcurrentDictionary();

private static Dictionary GetDefaultSimpleConverters()

{

...

}

private static List GetDefaultConverters()

{

...

}

public IList Converters { get; }

...

}

内置转换器

在 System.Text.Json 内置的转换器集合中&＃xff0c;涵盖了所有的基础数据类型&＃xff0c;这些转换器的设计非常精妙&＃xff0c;他们通过注册一系列的类型映射&＃xff0c;在通过 Utf8JsonWriter/Utf8JsonReader 的内置方法 GetTypeValue/TryGetTypeValue 方法得到值&＃xff0c;代码非常精练&＃xff0c;复用性非常高&＃xff0c;下面是内置类型转换器。

private static IEnumerable DefaultSimpleConverters

{

get

{

// When adding to this, update NumberOfSimpleConverters above.

yield return new JsonConverterBoolean();

yield return new JsonConverterByte();

yield return new JsonConverterByteArray();

yield return new JsonConverterChar();

yield return new JsonConverterDateTime();

yield return new JsonConverterDateTimeOffset();

yield return new JsonConverterDouble();

yield return new JsonConverterDecimal();

yield return new JsonConverterGuid();

yield return new JsonConverterInt16();

yield return new JsonConverterInt32();

yield return new JsonConverterInt64();

yield return new JsonConverterJsonElement();

yield return new JsonConverterObject();

yield return new JsonConverterSByte();

yield return new JsonConverterSingle();

yield return new JsonConverterString();

yield return new JsonConverterUInt16();

yield return new JsonConverterUInt32();

yield return new JsonConverterUInt64();

yield return new JsonConverterUri();

}

自定义类型转换器

虽然 System.Text.Json 内置了各种各样丰富的类型转换器&＃xff0c;但是在各种业务开发的过程中&＃xff0c;总会根据业务需求来决定一些特殊的数据类型的数据&＃xff0c;下面&＃xff0c;我们就以经典的日期/时间转换作为演示场景。

我们需要将日期类型输出为 Unix 时间戳而不是格式化的日期内容&＃xff0c;为此&＃xff0c;我们将实现一个自定义的时间格式转换器&＃xff0c;该转换器继承自 JsonConverter。

public class JsonConverterUnixDateTime : JsonConverter

{

private static DateTime Greenwich_Mean_Time &＃61; TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1), TimeZoneInfo.Local);

private const int Limit &＃61; 10000;

public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

{

if (reader.TokenType &＃61;&＃61; JsonTokenType.Number)

{

var unixTime &＃61; reader.GetInt64();

var dt &＃61; new DateTime(Greenwich_Mean_Time.Ticks &＃43; unixTime * Limit);

return dt;

}

else

{

return reader.GetDateTime();

}

public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)

{

var unixTime &＃61; (value - Greenwich_Mean_Time).Ticks / Limit;

writer.WriteNumberValue(unixTime);

}

应用自定义的时间转换器

转换器的应用形式有两种&＃xff0c;分别是将转换加入 JsonSerializerOptions.Converters 和给需要转换的属性添加特性标记 JsonConverter

加入Converters 方式

var options &＃61; new JsonSerializerOptions();

options.Converters.Add(new JsonConverterUnixDateTime());

var user &＃61; new UserInfo() { Age &＃61; 30, Name &＃61; "Ron", LoginTime &＃61; DateTime.Now };

var json &＃61; JsonSerializer.Serialize(user, options);

var deUser &＃61; JsonSerializer.Deserialize(json, options);

// JSON 输出

{"Name":"Ron","Age":30,"LoginTime":1577655080422}

应用 JsonConverter 特性方式

public class UserInfo

{

public string Name { get; set; }

public int Age { get; set; }

[JsonConverter(typeof(JsonConverterUnixDateTime))]

public DateTime LoginTime { get; set; }

}

var user &＃61; new UserInfo() { Age &＃61; 30, Name &＃61; "Ron", LoginTime &＃61; DateTime.Now };

var json &＃61; JsonSerializer.Serialize(user);

var deUser &＃61; JsonSerializer.Deserialize(json);

// JSON 输出

{"Name":"Ron","Age":30,"LoginTime":1577655080422}

注意上面的 UserInfo.LoginTime 的特性标记&＃xff0c;当你想小范围的对某些属性单独应用转换器的时候&＃xff0c;这种方式费用小巧而有效。

结束语

本文全面的介绍了 System.Text.Json 在各种场景下的用法&＃xff0c;并比较和 Newtonsoft.Json 使用上的不同&＃xff0c;也通过实例演示了具体的使用方法&＃xff0c;进一步深入讲解了 System.Text.Json 各种对象的原理&＃xff0c;希望对大家在迁移到.NETCore-3.1 的时候有所帮助。

最后&＃xff0c;欢迎点赞&＃xff01;