.NETCore3.1中的Json互操做最全解读-收藏级

时间 2020-01-02

标签 netcore3.1 netcore json 解读收藏栏目 JavaScript 繁體版

原文原文链接

前言

本文比较长，我建议你们先点赞、收藏后慢慢阅读，点赞再看，造成习惯！json

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

文档比较

几个重要的对象

在 System.Text.Json 中，有几个重量级的对象，全部的JSON互操做，都是围绕这几个对象进行，只要理解了他们各自的用途用法，就基本上掌握了JSON和实体对象的互操做。数组

JsonDocument

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

JsonElement

提供对JSON值的访问，在System.Text.Json 中，大到一个对象、数组，小到一个属性、值，均可以经过 JsonElement 进行互操做ide

JsonProperty

JSON中最小的单元，提供对属性、值的访问函数

JsonSerializer

提供JSON互操做的静态类，提供了一系列 Serializer/Deserialize 的互操做的方法，其中还有一些异步/流式操做方法。性能

JsonSerializerOptions

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

Utf8JsonWriter/Utf8JsonReader

这两个对象是整个 System.Text.Json 的核心对象，全部的JSON互操做几乎都是经过这两个对象进行，他们提供的高性能的底层读写操做。ui

初始化一个简单的 JSON 对象

在 System.Text.Json 中，并未提供像 JToken 那样很是便捷的建立对象的操做，想要建立一个 JSON 对象，其过程是比较麻烦的，请看下面的代码，进行对比this

// Newtonsoft.Json.Linq;
JToken root = new JObject();
root["Name"] = "Ron";
root["Money"] = 4.5;
root["Age"] = 30;
string jsonText = root.ToString();

// System.Text.Json
string json = string.Empty;
using (MemoryStream ms = new MemoryStream())
{
    using (Utf8JsonWriter writer = new Utf8JsonWriter(ms))
    {
        writer.WriteStartObject();
        writer.WriteString("Name", "Ron");
        writer.WriteNumber("Money", 4.5);
        writer.WriteNumber("Age", 30);
        writer.WriteEndObject();
        writer.Flush();
    }
    json = Encoding.UTF8.GetString(ms.ToArray());
}

System.Text.Json 的操做便利性在这方面目前处于一个比较弱的状态，不过，从这里也能够看出，可能官方并不但愿咱们去直接操做 JSON 源，而是经过操做实体对象以达到操做 JSON 的目的，也可能对互操做是性能比较自信的表现吧。

封装和加载

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

var json = "{\"name\":\"Ron\",\"money\":4.5}";

var jDoc = System.Text.Json.JsonDocument.Parse(json);
var jToken = Newtonsoft.Json.Linq.JToken.Parse(json);

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

查找元素（对象）

var json = "{\"name\":\"Ron\",\"money\":4.5}";
var jDoc = System.Text.Json.JsonDocument.Parse(json);
var obj = jDoc.RootElement[0];// 这里会报错，索引仅支持 Array 类型的JSON文档

var jToken = Newtonsoft.Json.Linq.JToken.Parse(json);
var name = jToken["name"];

你看，到查找元素环节就体现出差别了，JsonDocuemnt 索引仅支持 Array 类型的JSON文档，而 JToken 则支持 object 类型的索引（充满想象），用户体验高下立判。
那咱们不由要提问了，如何在 JsonDocument 中查找元素？答案以下。

var json = "{\"name\":\"Ron\",\"money\":4.5}";
var jDoc = System.Text.Json.JsonDocument.Parse(json);
var enumerate = jDoc.RootElement.EnumerateObject();
while (enumerate.MoveNext())
{
    if (enumerate.Current.Name == "name")
        Console.WriteLine("{0}:{1}", enumerate.Current.Name, enumerate.Current.Value);
}

从上面的代码来看，JsonElement 存在两个迭代器，分别是EnumerateArray和EnumerateObject；经过迭代器，你能够实现查找元素的需求。你看，MS关上了一扇门，而后又为了打开了一扇窗，仍是很人性化的了。在System.Text.Json中，一切对象都是Element，Object/Array/Property，都是Element，这个概念和XML一致，可是和Newtonsoft.Json不一样，这是须要注意的地方。

你也能够选择不迭代，直接获取对象的属性，好比使用下面的方法

var json = "{\"name\":\"Ron\",\"money\":4.5}";
var jDoc = System.Text.Json.JsonDocument.Parse(json);
var age = jDoc.RootElement.GetProperty("age");

上面这段代码将抛出异常，由于属性 age 不存在，一般状况下，咱们会当即想用一个 ContainsKey 来做一个判断，可是很惋惜，JsonElement 并未提供该方法，而是提供了一个 TryGetProperty 方法；因此，除非你明确知道 json 对象中的属性，不然通常状况下，建议使用 TryGetProperty 进行取值。

就算是这样，使用 GetProperty/TryGetProperty 获得的值，仍是一个 JsonElement 对象，并非你指望的“值”。因此 JsonElement 很人性化的提供了各类 GetIntxx/GetString 方法，可是就算如此，仍是可能产生意外，思考下面的代码：

var json = "{\"name\":\"Ron\",\"money\":4.5,\"age\":null}";
var jDoc = System.Text.Json.JsonDocument.Parse(json);
var property = jDoc.RootElement.GetProperty("age");
var age = property.GetInt32();

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

if (property.ValueKind == JsonValueKind.Number)
   {
       var age = property.GetInt32();
   }

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

public enum JsonValueKind : byte
{
    Undefined = 0,
    Object = 1,
    Array = 2,
    String = 3,
    Number = 4,
    True = 5,
    False = 6,
    Null = 7
}

看到这里，你是否是有点想念 Newtonsoft.Json 了呢？别着急，下面我给你们介绍一个宝贝 System.Json.dll。

System.Json

基本介绍

System.Json 提供了对JSON 对象序列化的基础支持，可是也是有限的支持，请看下图

System.Json 目前已合并到 .NETCore-3.1 中，若是你但愿使用他，须要单独引用

Install-Package System.Json -Version 4.7.0

这个JSON互操做包提供了几个经常使用的操做类型，从下面的操做类不难看出，提供的支持是很是有限的，并且效率上也很差说

System.Json.JsonArray
System.Json.JsonObject
System.Json.JsonPrimitive
System.Json.JsonValue

首先，JsonObject是实现 IDictionary 接口，并在内部维护一个 SortedDictionary<string, JsonValue> 字典，因此他具有字典类的一切操做，好比索引等等，JsonArray 就更简单，也是同样的实现 IList 接口，而后一样的在内部维护一个 List 链表，以实现数组功能，对象的序列化都是经过 JsonValue 进行操做，序列化的方式也是很是的简单，就是对对像进行迭代，惟一值得称道的地方是，采用了流式处理。

使用System.Json操做上面的查找过程以下

var obj = System.Json.JsonObject.Parse("{\"name\":\"ron\"}");
if (obj.ContainsKey("age"))
{
    int age = obj["age"];
}

使人遗憾的是，虽然 System.Json 已经合并到 .NETCore-3.1 的路线图中；可是，System.Text.Json 不提供对 System.Json 的互操做性，咱们期待之后 System.Text.Json 也能提供 System.Json 的操做便利性。

序列化和反序列化

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

互操做

思考下面的代码

// 序列化
var user = new UserInfo { Name = "Ron", Money = 4.5m, Age = 30 };
var json = JsonSerializer.Serialize(user);

// 输出
{"Name":"Ron","Money":4.5,"Age":30}

// 反序列化
user = JsonSerializer.Deserialize<UserInfo>(json);

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

// 输出
{"name":"Ron","money":4.5,"age":30}

// 反序列化
user = JsonSerializer.Deserialize<UserInfo>(json);

上面的代码能够正常运行，也不会抛出异常，你能够获得一个完整的 user 对象；可是，user对象的属性值将会丢失！这是由于 System.Text.Json 默认采用的是区分大小写匹配的方式，为了解决这个问题，咱们须要引入序列化操做个性化设置，请参考下面的代码，启用忽略大小写的设置

// 输出
{"name":"Ron","money":4.5,"age":30}

var options = new JsonSerializerOptions()
   {
       PropertyNameCaseInsensitive = true
   };
// 反序列化
user = JsonSerializer.Deserialize<UserInfo>(json,options);

格式化JSON

如今你能够选择对序列化的JSON文本进行美化，而不是输出上面的压缩后的JSON文本，为了实现美化的效果，你仅仅须要在序列化的时候加入一个 WriteIndented 设置

var options = new JsonSerializerOptions()
    options.WriteIndented = true;
 var user = new UserInfo { Name = "Ron", Money = 4.5m, Age = 30, Remark = "你好，欢迎！" };
 var json = JsonSerializer.Serialize(user, options);

 // 输出
{
  "Name": "Ron",
  "Money": 4.5,
  "Age": 30,
  "Remark": "\u4F60\u597D\uFF0C\u6B22\u8FCE\uFF01"
}

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

字符转义的问题

在默认状况下，System.Text.Json 序列化程序对全部非 ASCII 字符进行转义；这就是中文被转义的根本缘由。可是在内部，他又容许你自定义控制字符集的转义行为，这个设置就是：Encoder，好比下面的代码，对中文进行转义的例外设置，须要建立一个 TextEncoderSettings 对象，并将 UnicodeRanges.All 加入容许例外范围内，并使用 JavaScriptEncoder 根据 TextEncoderSettings建立一个 JavaScriptEncoder 对象便可。

var encoderSettings = new TextEncoderSettings();
encoderSettings.AllowRanges(UnicodeRanges.All);
var options = new JsonSerializerOptions();
options.Encoder = JavaScriptEncoder.Create(encoderSettings);
options.WriteIndented = true;
var user = new UserInfo { Name = "Ron", Money = 4.5m, Age = 30, Remark = "你好，欢迎！" };
var json = JsonSerializer.Serialize(user, options);

// 输出
{
  "Name": "Ron",
  "Money": 4.5,
  "Age": 30,
  "Remark": "你好，欢迎！"
}

还有另一种模式，能够没必要设置例外而达到不转义的效果，这个模式就是“非严格JSON”模式，将上面的 JavaScriptEncoder.Create(encoderSettings) 替换为下面的代码

options.Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping;

序列化相关-异步/流式

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

System.Text.Json.Utf8JsonReader
System.Text.Json.Utf8JsonWriter

自定义 JSON 名称和值

在默认状况下，输出的JSON属性名称保持和实体对象相同，包括大小写的都是一致的，枚举类型在默认状况下被序列化为数值类型。System.Text.JSON 提供了一系列的设置和扩展来帮助开发者实现各类自定义的需求。下面的代码能够设置默认的JSON属性名称，这个设置和 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 的时候，其字段名称将为：name，其余属性保持大小写不变

对全部属性设置为 camel 大小写

var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};

jsonSerializer.Serialize(user, options);

自定义名称策略

好比咱们的系统，目前采用全小写的模式，那么我能够自定义一个转换器，并应用到序列化行为中。

public class LowerCaseNamingPolicy : JsonNamingPolicy
{
    public override string ConvertName(string name) => name.ToLower();
}

var options = new JsonSerializerOptions();
// 应用策略
options.PropertyNamingPolicy = new LowerCaseNamingPolicy();

var user = new UserInfo { Name = "Ron", Money = 4.5m, Age = 30};
var json = JsonSerializer.Serialize(user, options);

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

var options = new JsonSerializerOptions();
// 添加转换器
options.Converters.Add(new JsonStringEnumConverter());

var user = new UserInfo { Name = "Ron", Money = 4.5m, Age = 30;
var json = JsonSerializer.Serialize(user, options);

排除不须要序列化的属性

在默认状况下，全部公共属性将被序列化为JSON。可是，若是你不想让某些属性出如今 JSON 中，能够经过下面的几种方式实现属性排除

排除全部属性值为 null 属性

var options = new JsonSerializerOptions();
options.Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping;
options.IgnoreNullValues = true;
var user = new UserInfo { Name = "Ron", Money = 4.5m, Age = 30, Remark =null};
var json = JsonSerializer.Serialize(user, options);

// 输出，能够看到，Remark 属性被排除
{"name":"Ron","Money":4.5,"Age":30}

排除指定标记属性

能够为某个属性应用 JsonIgnore 特性，标记为不输出到 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 = new UserInfo { Name = "Ron", Money = 4.5m, Age = 30, Remark =null};
var json = JsonSerializer.Serialize(user);

// 输出，属性 Age  已被排除
{"name":"Ron","Money":4.5,"Remark":null}

排除全部只读属性

还能够选择对全部只读属性进行排查输出 JSON，好比下面的代码，Password 是不须要输出的，那么咱们只须要将 Password 设置为 getter，并应用 IgnoreReadOnlyProperties = 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 = new JsonSerializerOptions
    {
        IgnoreReadOnlyProperties = true
    };
var user = new UserInfo { Name = "Ron", Money = 4.5m, Age = 30, Remark = null };
var json = JsonSerializer.Serialize(user, options);

// 输出
{"name":"Ron","Money":4.5,"Remark":null}

排除派生类的属性

在某些状况下，因为业务需求的不一样，须要实现实体对象的继承，可是在输出 JSON 的时候，但愿只输出基类的属性，而不要输出派生类型的属性，以免产生不可控制的数据泄露问题；那么，咱们能够采用下面的序列化设置。好比下面的 UserInfoExtension 派生自 UserInfo，并扩展了一个属性为身份证的属性，在输出 JSON 的时候，咱们但愿不要序列化派生类，那么咱们能够在 Serialize 序列化的时候，指定序列化的类型为基类：UserInfo，便可达到隐藏派生类属性的目的。

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 = new UserInfoExtension { Name = "Ron", Money = 4.5m, Age = 30, Remark = null };
var json = JsonSerializer.Serialize(user, typeof(UserInfo));

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

仅输出指定属性（排除属性的逆向操做）

在 Newtonsoft.Json 中，咱们能够经过指定 MemberSerialization 和 JsonProperty 来实现输出指定属性到 JSON 中，好比下面的代码

[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 = new UserInfo() { Age = 18, Name = "Ron" };
var json = Newtonsoft.Json.JsonConvert.SerializeObject(user);

// 输出
{"name":"Ron"}

不过，很遗憾的告诉你们，目前 System.Text.Json 不支持这种方式；为此，我特地去看了 corefx 的 issue，我看到了下面这个反馈

如今能够方向了，当 .NETCore 合并到主分支 .NET 也就是 .NET5.0 的时候，官方将提供支持，在此以前，仍是使用推荐 Newtonsoft.Json 。

在反序列化的时候，容许 JSON 文本包含注释

默认状况下，System.Text.JSON 不支持源JSON 文本包含注释，好比下面的代码，当你不使用 ReadCommentHandling = JsonCommentHandling.Skip 的设置的时候，将抛出异常，由于在字段 Age 的后面有注释 /* age */。

var jsonText = "{\"Name\":\"Ron\",\"Money\":4.5,\"Age\":30/* age */}";
var options = new JsonSerializerOptions
{
    ReadCommentHandling = JsonCommentHandling.Skip,
    AllowTrailingCommas = true,
};
var user = JsonSerializer.Deserialize<UserInfoExtension>(jsonText);

容许字段溢出

在接口数据出现变更时，极有可能出现源 JSON 文本和实体对象属性不匹配的问题，JSON 中可能会多出一些实体对象不存在的属性，这种状况咱们称之为“溢出”，在默认状况下，溢出的属性将被忽略，若是但愿捕获这些“溢出”的属性，能够在实体对象中声明一个类型为：Dictionary<string, object> 的属性，并对其应用特性标记：JsonExtensionData。

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

public class UserInfo
{
    public string Name { get; set; }
    public int Age { get; set; }
    [JsonExtensionData] public Dictionary<string, object> ExtensionData { get; set; }
}

var jsonText = "{\"Name\":\"Ron\",\"Money\":4.5,\"Age\":30}";
var user = JsonSerializer.Deserialize<UserInfo>(jsonText);

输出截图

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

转换器

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

public sealed partial class JsonSerializerOptions
{
    // The global list of built-in simple converters.
    private static readonly Dictionary<Type, JsonConverter> s_defaultSimpleConverters = GetDefaultSimpleConverters();
    // The global list of built-in converters that override CanConvert().
    private static readonly List<JsonConverter> s_defaultFactoryConverters = GetDefaultConverters();
    // The cached converters (custom or built-in).
    private readonly ConcurrentDictionary<Type, JsonConverter> _converters = new ConcurrentDictionary<Type, JsonConverter>();

    private static Dictionary<Type, JsonConverter> GetDefaultSimpleConverters()
        {
            ...
        }

        private static List<JsonConverter> GetDefaultConverters()
        {
           ...
        }

        public IList<JsonConverter> Converters { get; }
        ...
}

内置转换器

在 System.Text.Json 内置的转换器集合中，涵盖了全部的基础数据类型，这些转换器的设计很是精妙，他们经过注册一系列的类型映射，在经过 Utf8JsonWriter/Utf8JsonReader 的内置方法 GetTypeValue/TryGetTypeValue 方法获得值，代码很是精练，复用性很是高，下面是内置类型转换器。

private static IEnumerable<JsonConverter> 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 内置了各类各样丰富的类型转换器，可是在各类业务开发的过程当中，总会根据业务需求来决定一些特殊的数据类型的数据，下面，咱们就以经典的日期/时间转换做为演示场景。

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

public class JsonConverterUnixDateTime : JsonConverter<DateTime>
{
    private static DateTime Greenwich_Mean_Time = TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1), TimeZoneInfo.Local);
    private const int Limit = 10000;
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType == JsonTokenType.Number)
        {
            var unixTime = reader.GetInt64();
            var dt = new DateTime(Greenwich_Mean_Time.Ticks + unixTime * Limit);
            return dt;
        }
        else
        {
            return reader.GetDateTime();
        }
    }
    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
        var unixTime = (value - Greenwich_Mean_Time).Ticks / Limit;
        writer.WriteNumberValue(unixTime);
    }
}

应用自定义的时间转换器

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

加入Converters 方式

var options = new JsonSerializerOptions();
options.Converters.Add(new JsonConverterUnixDateTime());
var user = new UserInfo() { Age = 30, Name = "Ron", LoginTime = DateTime.Now };
var json = JsonSerializer.Serialize(user, options);
var deUser = JsonSerializer.Deserialize<UserInfo>(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 = new UserInfo() { Age = 30, Name = "Ron", LoginTime = DateTime.Now };
var json = JsonSerializer.Serialize(user);
var deUser = JsonSerializer.Deserialize<UserInfo>(json);

// JSON 输出
{"Name":"Ron","Age":30,"LoginTime":1577655080422}

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

结束语

本文全面的介绍了 System.Text.Json 在各类场景下的用法，并比较和 Newtonsoft.Json 使用上的不一样，也经过实例演示了具体的使用方法，进一步深刻讲解了 System.Text.Json 各类对象的原理，但愿对你们在迁移到.NETCore-3.1 的时候有所帮助。

最后，欢迎点赞！