前言

本文比較長，我建議大家先點贊、收藏后慢慢閱讀，點贊再看，形成習慣！

我很高興,.NETCore終于來到了3.1LTS版本，并且將支持3年，我們也準備讓部分業務遷移到3.1上面，不過很快我們就遇到了新的問題，就是對于Json序列化的選擇；我本著清真的原則，既然選擇遷移到3.1，一切都應該用官方標準或者建議方案，所以我們信心滿滿的選擇了System.Text.Json，本文將會全面介紹System.Text.Json 和 Newtonsoft.Json 的相同和異同之處，方便需要的同學做遷移使用，對未來，我們保持期待，

檔案比較

幾個重要的物件

在 System.Text.Json 中，有幾個重量級的物件，所有的JSON互操作，都是圍繞這幾個物件進行，只要理解了他們各自的用途用法，就基本上掌握了JSON和物體物件的互操作，

JsonDocument

提供用于檢查 JSON 值的結構內容，而不自動實體化資料值的機制，JsonDocument 有一個屬性 RootElement，提供對JSON檔案根元素的訪問，RootElement是一個JsonElement物件，

JsonElement

提供對JSON值的訪問，在System.Text.Json 中，大到一個物件、陣列，小到一個屬性、值，都可以通過 JsonElement 進行互操作

JsonProperty

JSON中最小的單元，提供對屬性、值的訪問

JsonSerializer

提供JSON互操作的靜態類，提供了一系列 Serializer/Deserialize 的互操作的方法，其中還有一些異步/流式操作方法，

JsonSerializerOptions

與上面的 JsonSerializer 配合使用，提供自定義的個性化互操作選項，包括命名、列舉轉換、字符轉義、注釋規則、自定義轉換器等等操作選項，

Utf8JsonWriter/Utf8JsonReader

這兩個物件是整個 System.Text.Json 的核心物件，所有的JSON互操作幾乎都是通過這兩個物件進行，他們提供的高性能的底層讀寫操作，

初始化一個簡單的 JSON 物件

在 System.Text.Json 中，并未提供像 JToken 那樣非常便捷的創建物件的操作，想要創建一個 JSON 物件，其程序是比較麻煩的，請看下面的代碼，進行對比

 // 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 的時候有所幫助，

最后，歡迎點贊！

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/77433.html

標籤：.NET Core

上一篇：聊聊多執行緒那一些事兒（task）之二延續操作

下一篇：ASP.NET Core 2.1 中的 HttpClientFactory (Part 4) 整合Polly實作瞬時故障處理

.NETCore3.1中的Json互操作最全解讀-收藏級

前言