Newtonsoft.Json 你必須知道的一些用法

時間 2019-11-06

標籤 newtonsoft.json newtonsoft json 必須知道一些用法欄目 JSON 简体版

原文原文鏈接

　　最近在作接口開發，對方團隊開發了一個Web API 的接口，傳輸數據的格式是 JSON。當時看到這個東西，感受很簡單，也沒想什麼，沒用多久就完成了個人功能，我完成的功能很簡單，就是獲取數據，而後把數據列表進行 JSON 序列化，而後再以 POST 方式調用對方 Web Api 的接口，將 JSON 的數據一塊兒傳遞過去，我想的很簡單，直接調用並返回結果就完成了。最後對方接口返回錯誤，提示從傳遞過去的 JSON 數據中的第一個字段開始就取不到值。

　　鬱悶，爲何呢？個人參數也是按着他們接口的規範寫的，數據獲取也沒錯，JSON 格式化的數據好像也正常，對方團隊的 Api 接口爲何提示取不到值。後來，靜下心來，仔細看了看個人項目，應該沒啥大問題。忽然，好像感受找到了緣由，可是感受不該該是這個問題，那就是我傳遞的 JSON 數據的 Key 值的名稱採用的是 Pascal 命名法，就是每一個單詞的首字符都是大寫的（{「BoyFirend」:「xxx」,"HomeAddress":"xxxx"}），而對方的 Key 的命名法是 Camel 命名法（好比：{「boyFirend」:「xxx」,"homeAddress":"xxxx"}）。之因此產生這個結果，由於 JSON 數據是直接經過 C#的實體類序列化而來的，在 C# 中的實體類的每一個屬性的命名就是採用的是 Pascal 命名方法。找到了緣由，可是不太肯定，而後一試，還這是這樣緣由。

　　緣由找到了，解決問題就簡單了，對方團隊寫的 Api 接口我的感受兼容很差，不該該對大小寫敏感，讓接口更通用一點纔好，我建議對方改一下接口，對方好像不怎麼贊成，那我只能修改個人接口了。說到 JSON 序列化，我使用的是 Newtonsoft.Json，這個東東，你們應該很熟悉吧。因爲對它研究不深，就上網找了一會兒，不錯，還真有解決辦法，那我也收藏一下，便於之後查閱。前端

1、Newtonsoft.Json介紹

　　作 Web 開發的，沒有接觸過 JavaScript 的確定不多，作前端開發，沒有接觸過Ajax的估計更很少了。如今的系統大多數是分佈式系統，分佈式系統就會涉及到數據的傳輸，JSON在數據傳輸和提交方面有着天生的優點。當咱們使用Json的時候，不少時候會涉及到幾個序列化對象的使用：DataContractJsonSerializer,JavaScriptSerializer 和 Json.NET即 Newtonsoft.Json。大多數人都會選擇性能以及通用性較好 Json.NET，這個不是微軟的類庫，是一個開源的Json操做類庫，速度比 DataContractJsonSerializer 快 50%，比 JavaScriptSerializer 快 250%，從下面的性能對比就能夠看到它的其中之一的性能優勢。json

　　　　它的確很快，使用也很簡單，它支持序列化的對象也不少，我剛開始覺得只是支持以實體類爲基礎的序列化，其實還有不少，好比，數據表（DataTable），數據集（DataSet）等，你瞭解越深就越喜歡它，也避免你在不知的狀況下「重複造輪子」。數組

2、基本用法

　　Json.Net是支持序列化和反序列化DataTable,DataSet,Entity Framework和Entity的。下面分別舉例說明序列化和反序列化。分佈式

DataTable：ide

 1             //序列化DataTable
 2             DataTable dt = new DataTable();
 3             dt.Columns.Add("Age", Type.GetType("System.Int32"));
 4             dt.Columns.Add("Name", Type.GetType("System.String"));
 5             dt.Columns.Add("Sex", Type.GetType("System.String"));
 6             dt.Columns.Add("IsMarry", Type.GetType("System.Boolean"));
 7             for (int i = 0; i < 4; i++)
 8             {
 9                 DataRow dr = dt.NewRow();
10                 dr["Age"] = i + 1;
11                 dr["Name"] = "Name" + i;
12                 dr["Sex"] = i % 2 == 0 ? "男" : "女";
13                 dr["IsMarry"] = i % 2 > 0 ? true : false;
14                 dt.Rows.Add(dr);
15             }
16             Console.WriteLine(JsonConvert.SerializeObject(dt));

　　利用上面字符串進行反序列化函數

1 string json = JsonConvert.SerializeObject(dt);
2  dt=JsonConvert.DeserializeObject<DataTable>(json);
3  foreach (DataRow dr in dt.Rows)
4  {
5  　　Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", dr[0], dr[1], dr[2], dr[3]);
6  }

　　Entity序列化和DataTable同樣，就不過多介紹了。性能

3、高級用法

　　1.忽略某些屬性學習

　　 2.默認值的處理this

　　3.空值的處理spa

　　4.支持非公共成員

　　5.日期處理

　　6.自定義序列化的字段名稱

　　　7.動態決定屬性是否序列化

　　8.枚舉值的自定義格式化問題

　　　 9.自定義類型轉換

　　 10.全局序列化設置

　　 1.忽略某些屬性

　　　　咱們在序列化的過程當中，並非全部屬性都須要序列化的，若是實體中有些屬性不須要序列化，可使用該特性。首先介紹Json.Net序列化的模式:OptOut 和 OptIn

OptOut	默認值,類中全部公有成員會被序列化,若是不想被序列化,能夠用特性JsonIgnore
OptIn	默認狀況下,全部的成員不會被序列化,類中的成員只有標有特性JsonProperty的纔會被序列化,當類的成員不少,但客戶端僅僅須要一部分數據時,頗有用

　　　僅須要姓名屬性

 1     [JsonObject(MemberSerialization.OptIn)]
 2     public class Person
 3     {
 4         public int Age { get; set; }
 5 
 6         [JsonProperty]
 7         public string Name { get; set; }
 8 
 9         public string Sex { get; set; }
10 
11         public bool IsMarry { get; set; }
12 
13         public DateTime Birthday { get; set; }
14     }

　　不須要是否結婚屬性

 1     [JsonObject(MemberSerialization.OptOut)]
 2     public class Person
 3     {
 4         public int Age { get; set; }
 5 
 6         public string Name { get; set; }
 7 
 8         public string Sex { get; set; }
 9 
10         [JsonIgnore]
11         public bool IsMarry { get; set; }
12 
13         public DateTime Birthday { get; set; }
14     }

　　經過上面的例子能夠看到，要實現不返回某些屬性的需求很簡單。1.在實體類上加上[JsonObject(MemberSerialization.OptOut)] 2.在不須要返回的屬性上加上 [JsonIgnore]說明。

　　2.默認值處理

　　序列化時想忽略默認值屬性能夠經過JsonSerializerSettings.DefaultValueHandling來肯定，該值爲枚舉值

DefaultValueHandling.Ignore	序列化和反序列化時,忽略默認值
DefaultValueHandling.Include	序列化和反序列化時,包含默認值

 [DefaultValue(10)] public int Age { get; set; }

 Person p = new Person { Age = 10, Name = "張三丰", Sex = "男", IsMarry = false, Birthday = new DateTime(1991, 1, 2) }; JsonSerializerSettings jsetting=new JsonSerializerSettings(); jsetting.DefaultValueHandling=DefaultValueHandling.Ignore; Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

　　最終結果以下：

　　3.空值的處理

　　　　序列化時須要忽略值爲NULL的屬性，能夠經過JsonSerializerSettings.NullValueHandling來肯定，另外經過JsonSerializerSettings設置屬性是對序列化過程當中全部屬性生效的，想單獨對某一個屬性生效可使用JsonProperty，下面將分別展現兩個方式

　　　　1）.JsonSerializerSettings

 Person p = new Person { room=null,Age = 10, Name = "張三丰", Sex = "男", IsMarry = false, Birthday = new DateTime(1991, 1, 2) }; JsonSerializerSettings jsetting=new JsonSerializerSettings(); jsetting.NullValueHandling = NullValueHandling.Ignore; Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

　　 2）.JsonProperty

　　　　經過JsonProperty屬性設置的方法，能夠實現某一屬性特別處理的需求，如默認值處理，空值處理，自定義屬性名處理，格式化處理。上面空值處理實現

 [JsonProperty(NullValueHandling=NullValueHandling.Ignore)]
 public Room room { get; set; }

　　4.支持非公共成員

　　序列化時默認都是處理公共成員，若是須要處理非公共成員，就要在該成員上加特性"JsonProperty"

 [JsonProperty]
 private int Height { get; set; }

　　5.日期處理

　　　　對於Dateime類型日期的格式化就比較麻煩了，系統自帶的會格式化成iso日期標準，可是實際使用過程當中大多數使用的多是yyyy-MM-dd 或者yyyy-MM-dd HH:mm:ss兩種格式的日期，解決辦法是能夠將DateTime類型改爲string類型本身格式化好，而後在序列化。若是不想修改代碼，能夠採用下面方案實現。

　　Json.Net提供了IsoDateTimeConverter日期轉換這個類，能夠經過JsnConverter實現相應的日期轉換

    [JsonConverter(typeof(IsoDateTimeConverter))] public DateTime Birthday { get; set; }

　　　　可是IsoDateTimeConverter日期格式不是咱們想要的，咱們能夠繼承該類實現本身的日期

 1     public class ChinaDateTimeConverter : DateTimeConverterBase
 2     {
 3         private static IsoDateTimeConverter dtConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd" };
 4 
 5         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 6         {
 7             return dtConverter.ReadJson(reader, objectType, existingValue, serializer);
 8         }
 9 
10         public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
11         {
12             dtConverter.WriteJson(writer, value, serializer);
13         }
14     }

　　本身實現了一個yyyy-MM-dd格式化轉換類，能夠看到只是初始化IsoDateTimeConverter時給的日期格式爲yyyy-MM-dd便可，下面看下效果

[JsonConverter(typeof(ChinaDateTimeConverter))] public DateTime Birthday { get; set; }

　　能夠根據本身需求實現不一樣的轉換類

　　6.自定義序列化的字段名稱

　　　　實體中定義的屬性名可能不是本身想要的名稱，可是又不能更改實體定義，這個時候能夠自定義序列化字段名稱。

     [JsonProperty(PropertyName = "CName")] public string Name { get; set; }

　　7.動態決定屬性是否序列化

　　　　這個是爲了實現@米粒兒提的需求特別增長的，根據某些場景，可能A場景輸出A，B，C三個屬性，B場景輸出E，F屬性。雖然實際中不必定存在這種需求，可是json.net依然能夠支持該特性。

　　　　繼承默認的DefaultContractResolver類，傳入須要輸出的屬性

　　重寫修改了一下，大多數狀況下應該是要排除的字段少於要保留的字段, 爲了方便書寫這裏修改了構造函數加入retain表示props是須要保留的字段仍是要排除的字段

 1     public class LimitPropsContractResolver : DefaultContractResolver
 2     {
 3         string[] props = null;
 4 
 5         bool retain;
 6 
 7         /// <summary>
 8         /// 構造函數
 9         /// </summary>
10         /// <param name="props">傳入的屬性數組</param>
11         /// <param name="retain">true:表示props是須要保留的字段  false：表示props是要排除的字段</param>
12         public LimitPropsContractResolver(string[] props, bool retain=true)
13         {
14             //指定要序列化屬性的清單
15             this.props = props;
16 
17             this.retain = retain;
18         }
19 
20         protected override IList<JsonProperty> CreateProperties(Type type,
21 
22         MemberSerialization memberSerialization)
23         {
24             IList<JsonProperty> list =
25             base.CreateProperties(type, memberSerialization);
26             //只保留清單有列出的屬性
27             return list.Where(p => {
28                 if (retain)
29                 {
30                     return props.Contains(p.PropertyName);
31                 }
32                 else
33                 {
34                     return !props.Contains(p.PropertyName);
35                 }      
36             }).ToList();
37         }

 public string Sex { get; set; }

      JsonSerializerSettings jsetting=new JsonSerializerSettings(); jsetting.ContractResolver = new LimitPropsContractResolver(new string[] { "Age", "IsMarry" }); Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

　　使用自定義的解析類，只輸出"Age", "IsMarry"兩個屬性，看下最終結果.只輸出了Age屬性，爲何IsMarry屬性沒有輸出呢，由於標註了JsonIgnore

　　看到上面的結果想要實現pc端序列化一部分，手機端序列化另外一部分就很簡單了吧，咱們改下代碼實現一下

 1   string[] propNames = null;
 2   if (p.Age > 10)
 3   {
 4   　　propNames = new string[] { "Age", "IsMarry" };
 5   }
 6   else
 7   {
 8       propNames = new string[] { "Age", "Sex" };
 9   }
10   jsetting.ContractResolver = new LimitPropsContractResolver(propNames);
11   Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

　　8.枚舉值的自定義格式化問題

　　　　默認狀況下對於實體裏面的枚舉類型系統是格式化成改枚舉對應的整型數值,那若是須要格式化成枚舉對應的字符怎麼處理呢？Newtonsoft.Json也幫咱們想到了這點，下面看實例

 1     public enum NotifyType
 2     {
 3         /// <summary>
 4         /// Emil發送
 5         /// </summary>
 6         Mail=0,
 7 
 8         /// <summary>
 9         /// 短信發送
10         /// </summary>
11         SMS=1
12     }
13 
14     public class TestEnmu
15     {
16         /// <summary>
17         /// 消息發送類型
18         /// </summary>
19         public NotifyType Type { get; set; }
20     }
21     JsonConvert.SerializeObject(new TestEnmu());

　　　　輸出結果：如今改造一下，輸出"Type":"Mail"

1     public class TestEnmu
2     {
3         /// <summary>
4         /// 消息發送類型
5         /// </summary>
6         [JsonConverter(typeof(StringEnumConverter))]
7         public NotifyType Type { get; set; }
8     }

　　　　其它的都不變，在Type屬性上加上了JsonConverter(typeof(StringEnumConverter))表示將枚舉值轉換成對應的字符串,而StringEnumConverter是Newtonsoft.Json內置的轉換類型,最終輸出結果

　　9.自定義類型轉換

　　　　默認狀況下對於實體裏面的Boolean系統是格式化成true或者false,對於true轉成"是" false轉成"否"這種需求改怎麼實現了？咱們能夠自定義類型轉換實現該需求，下面看實例

  1     public class BoolConvert : JsonConverter
  2     {
  3         private string[] arrBString { get; set; }
  4 
  5         public BoolConvert()
  6         {
  7             arrBString = "是,否".Split(',');
  8         }
  9 
 10         /// <summary>
 11         /// 構造函數
 12         /// </summary>
 13         /// <param name="BooleanString">將bool值轉換成的字符串值</param>
 14         public BoolConvert(string BooleanString)
 15         {
 16             if (string.IsNullOrEmpty(BooleanString))
 17             {
 18                 throw new ArgumentNullException();
 19             }
 20             arrBString = BooleanString.Split(',');
 21             if (arrBString.Length != 2)
 22             {
 23                 throw new ArgumentException("BooleanString格式不符合規定");
 24             }
 25         }
 26 
 27 
 28         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 29         {
 30             bool isNullable = IsNullableType(objectType);
 31             Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;
 32 
 33             if (reader.TokenType == JsonToken.Null)
 34             {
 35                 if (!IsNullableType(objectType))
 36                 {
 37                     throw new Exception(string.Format("不能轉換null value to {0}.", objectType));
 38                 }
 39 
 40                 return null;
 41             }
 42 
 43             try
 44             {
 45                 if (reader.TokenType == JsonToken.String)
 46                 {
 47                     string boolText = reader.Value.ToString();
 48                     if (boolText.Equals(arrBString[0], StringComparison.OrdinalIgnoreCase))
 49                     {
 50                         return true;
 51                     }
 52                     else if (boolText.Equals(arrBString[1], StringComparison.OrdinalIgnoreCase))
 53                     {
 54                         return false;
 55                     }
 56                 }
 57 
 58                 if (reader.TokenType == JsonToken.Integer)
 59                 {
 60                     //數值
 61                     return Convert.ToInt32(reader.Value) == 1;
 62                 }
 63             }
 64             catch (Exception ex)
 65             {
 66                 throw new Exception(string.Format("Error converting value {0} to type '{1}'", reader.Value, objectType));
 67             }
 68             throw new Exception(string.Format("Unexpected token {0} when parsing enum", reader.TokenType));
 69         }
 70 
 71         /// <summary>
 72         /// 判斷是否爲Bool類型
 73         /// </summary>
 74         /// <param name="objectType">類型</param>
 75         /// <returns>爲bool類型則能夠進行轉換</returns>
 76         public override bool CanConvert(Type objectType)
 77         {
 78             return true;
 79         }
 80 
 81 
 82         public bool IsNullableType(Type t)
 83         {
 84             if (t == null)
 85             {
 86                 throw new ArgumentNullException("t");
 87             }
 88             return (t.BaseType.FullName=="System.ValueType" && t.GetGenericTypeDefinition() == typeof(Nullable<>));
 89         }
 90 
 91         public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 92         {
 93             if (value == null)
 94             {
 95                 writer.WriteNull();
 96                 return;
 97             }
 98 
 99             bool bValue = (bool)value;
100 
101             if (bValue)
102             {
103                 writer.WriteValue(arrBString[0]);
104             }
105             else
106             {
107                 writer.WriteValue(arrBString[1]);
108             }
109         }
110     }
111 
112

　　　　　　自定義了BoolConvert類型，繼承自JsonConverter。構造函數參數BooleanString可讓咱們自定義將true false轉換成相應字符串。下面看實體裏面怎麼使用這個自定義轉換類型

    public class Person { [JsonConverter(typeof(BoolConvert))] public bool IsMarry { get; set; } }

　　　　　　‘

　　　　　　相應的有什麼個性化的轉換需求，均可以使用自定義轉換類型的方式實現。

　　　10.全局序列化設置

　　　　　　文章開頭提出了Null值字段怎麼不返回的問題，相應的在高級用法也給出了相應的解決方案使用jsetting.NullValueHandling = NullValueHandling.Ignore; 來設置不返回空值。這樣有個麻煩的地方，每一個不想返回空值的序列化都需設置一下。能夠對序列化設置一些默認值方式麼？下面將解答

 1 　　Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();
 2    JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() =>
 3    {
 4 　　　　//日期類型默認格式化處理
 5    　　setting.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
 6       setting.DateFormatString = "yyyy-MM-dd HH:mm:ss";
 7 
 8 　　　 //空值處理
 9       setting.NullValueHandling = NullValueHandling.Ignore;
10 
11       //高級用法九中的Bool類型轉換 設置
12       setting.Converters.Add(new BoolConvert("是,否"));
13 
14       return setting;
15    });

　　　　這樣設置之後，之後使用序列化的地方就不須要單獨設置了，我的最喜歡設置的是空值處理這一塊。

4、總結

　　　　今天就到這裏了，它涉及的內容太多了，咱們只是接觸了皮毛，官網地址以下：https://www.newtonsoft.com/json。經過一個小問題，學習了一個大知識點，當本身不深刻的時候，對一些事情的判斷就可能有失偏頗，若是想讓本身把技術運用的駕輕就熟，就要深刻進去，瞭解其裏，纔能有所得。