手機端應用講究速度快，體驗好。剛好手頭上的一個項目服務端接口有性能問題，需要進行優化。在接口多次修改中，實體添加了很多字段用於中間計算或者存儲，然後最終用Newtonsoft.Json進行序列化返回數據，經過分析一個簡單的列表接口每一行數據返回了16個字段，但是手機APP端只用到了其中7個字段，剩餘9個字段的數據全部都是多餘的，如果接口返回數據爲40K大小，也就是說大約20K的數據爲無效數據，3G網絡下20K下載差不多需要1s，不返回無效數據至少可以節約1s的時間，大大提高用戶體驗。本篇將爲大家介紹Newtonsoft.Json的一些高級用法，可以修改很少的代碼解決上述問題。

閱讀目錄

Newtonsoft.Json介紹

　　在做開發的時候，很多數據交換都是以json格式傳輸的。而使用Json的時候，我們很多時候會涉及到幾個序列化對象的使用：DataContractJsonSerializer,JavaScriptSerializer 和 Json.NET即Newtonsoft.Json。大多數人都會選擇性能以及通用性較好Json.NET，這個不是微軟的類庫，但是一個開源的世界級的Json操作類庫，從下面的性能對比就可以看到它的其中之一的性能優點。

齊全的API介紹，使用方式簡單

回到頂部

基本用法

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

DataTable：

            //序列化DataTable

            DataTable dt = new DataTable();

            dt.Columns.Add("Age", Type.GetType("System.Int32"));

            dt.Columns.Add("Name", Type.GetType("System.String"));

            dt.Columns.Add("Sex", Type.GetType("System.String"));

            dt.Columns.Add("IsMarry", Type.GetType("System.Boolean"));

            for (int i = 0; i < 4; i++)

                DataRow dr = dt.NewRow();

                dr["Age"] = i + 1;

                dr["Name"] = "Name" + i;

                dr["Sex"] = i % 2 == 0 ? "男" : "女";

                dr["IsMarry"] = i % 2 > 0 ? true : false;

                dt.Rows.Add(dr);

            Console.WriteLine(JsonConvert.SerializeObject(dt));

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

 string json = JsonConvert.SerializeObject(dt);

 dt=JsonConvert.DeserializeObject<DataTable>(json);

 foreach (DataRow dr in dt.Rows)

 　　Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", dr[0], dr[1], dr[2], dr[3]);

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

回到頂部

高級用法

1.忽略某些屬性

2.默認值的處理

3.空值的處理

4.支持非公共成員

5.日期處理

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

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

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

　 9.自定義類型轉換

10.全局序列化設置

一.忽略某些屬性

　　類似本問開頭介紹的接口優化，實體中有些屬性不需要序列化返回，可以使用該特性。首先介紹Json.Net序列化的模式:OptOut 和 OptIn

OptOut	默認值,類中所有公有成員會被序列化,如果不想被序列化,可以用特性JsonIgnore
OptIn	默認情況下,所有的成員不會被序列化,類中的成員只有標有特性JsonProperty的纔會被序列化,當類的成員很多,但客戶端僅僅需要一部分數據時,很有用

　僅需要姓名屬性

    [JsonObject(MemberSerialization.OptIn)]

    public class Person

        public int Age { get; set; }

        [JsonProperty]

        public string Name { get; set; }

        public string Sex { get; set; }

        public bool IsMarry { get; set; }

        public DateTime Birthday { get; set; }

不需要是否結婚屬性

    [JsonObject(MemberSerialization.OptOut)]

    public class Person

        public int Age { get; set; }

        public string Name { get; set; }

        public string Sex { get; set; }

        [JsonIgnore]

        public bool IsMarry { get; set; }

        public DateTime Birthday { get; set; }

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

二.默認值處理

序列化時想忽略默認值屬性可以通過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));

最終結果如下：

三.空值的處理

　　序列化時需要忽略值爲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; }

四.支持非公共成員

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

 [JsonProperty]

 private int Height { get; set; }

五.日期處理

　　對於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日期格式不是我們想要的，我們可以繼承該類實現自己的日期

    public class ChinaDateTimeConverter : DateTimeConverterBase

        private static IsoDateTimeConverter dtConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd" };

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

            return dtConverter.ReadJson(reader, objectType, existingValue, serializer);

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

            dtConverter.WriteJson(writer, value, serializer);

自己實現了一個yyyy-MM-dd格式化轉換類，可以看到只是初始化IsoDateTimeConverter時給的日期格式爲yyyy-MM-dd即可，下面看下效果

[JsonConverter(typeof(ChinaDateTimeConverter))]

public DateTime Birthday { get; set; }

可以根據自己需求實現不同的轉換類

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

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

     [JsonProperty(PropertyName = "CName")]

     public string Name { get; set; }

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

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

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

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

public class LimitPropsContractResolver : DefaultContractResolver

        string[] props = null;

        bool retain;

        /// <summary>

        /// 構造函數

        /// </summary>

        /// <param name="props">傳入的屬性數組</param>

        /// <param name="retain">true:表示props是需要保留的字段  false：表示props是要排除的字段</param>

        public LimitPropsContractResolver(string[] props, bool retain=true)

            //指定要序列化屬性的清單

            this.props = props;

            this.retain = retain;

        protected override IList<JsonProperty> CreateProperties(Type type,

        MemberSerialization memberSerialization)

            IList<JsonProperty> list =

            base.CreateProperties(type, memberSerialization);

            //只保留清單有列出的屬性

            return list.Where(p => {

                if (retain)

                    return props.Contains(p.PropertyName);

                else

                    return !props.Contains(p.PropertyName);

            }).ToList();

        public int Age { get; set; }

        [JsonIgnore]

        public bool IsMarry { get; set; }

        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端序列化一部分，手機端序列化另一部分就很簡單了吧，我們改下代碼實現一下

  string[] propNames = null;

  if (p.Age > 10)

  　　propNames = new string[] { "Age", "IsMarry" };

  else

      propNames = new string[] { "Age", "Sex" };

  jsetting.ContractResolver = new LimitPropsContractResolver(propNames);

  Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

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

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

    public enum NotifyType

        /// <summary>

        /// Emil發送

        /// </summary>

        Mail=0,

        /// <summary>

        /// 短信發送

        /// </summary>

        SMS=1

    public class TestEnmu

        /// <summary>

        /// 消息發送類型

        /// </summary>

        public NotifyType Type { get; set; }

    JsonConvert.SerializeObject(new TestEnmu());

輸出結果：現在改造一下，輸出"Type":"Mail"

    public class TestEnmu

        /// <summary>

        /// 消息發送類型

        /// </summary>

        [JsonConverter(typeof(StringEnumConverter))]

        public NotifyType Type { get; set; }

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

九.自定義類型轉換

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

public class BoolConvert : JsonConverter

        private string[] arrBString { get; set; }

        public BoolConvert()

            arrBString = "是,否".Split(',');

        /// <summary>

        /// 構造函數

        /// </summary>

        /// <param name="BooleanString">將bool值轉換成的字符串值</param>

        public BoolConvert(string BooleanString)

            if (string.IsNullOrEmpty(BooleanString))

                throw new ArgumentNullException();

            arrBString = BooleanString.Split(',');

            if (arrBString.Length != 2)

                throw new ArgumentException("BooleanString格式不符合規定");

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

            bool isNullable = IsNullableType(objectType);

            Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;

            if (reader.TokenType == JsonToken.Null)

                if (!IsNullableType(objectType))

                    throw new Exception(string.Format("不能轉換null value to {0}.", objectType));

                return null;

try

                if (reader.TokenType == JsonToken.String)

                    string boolText = reader.Value.ToString();

                    if (boolText.Equals(arrBString[0], StringComparison.OrdinalIgnoreCase))

                        return true;

                    else if (boolText.Equals(arrBString[1], StringComparison.OrdinalIgnoreCase))

                        return false;

                if (reader.TokenType == JsonToken.Integer)

                    //數值

                    return Convert.ToInt32(reader.Value) == 1;

            catch (Exception ex)

                throw new Exception(string.Format("Error converting value {0} to type '{1}'", reader.Value, objectType));

            throw new Exception(string.Format("Unexpected token {0} when parsing enum", reader.TokenType));

        /// <summary>

        /// 判斷是否爲Bool類型

        /// </summary>

        /// <param name="objectType">類型</param>

        /// <returns>爲bool類型則可以進行轉換</returns>

        public override bool CanConvert(Type objectType)

            return true;

        public bool IsNullableType(Type t)

            if (t == null)

                throw new ArgumentNullException("t");

            return (t.BaseType.FullName=="System.ValueType" && t.GetGenericTypeDefinition() == typeof(Nullable<>));

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

            if (value == null)

                writer.WriteNull();

                return;

            bool bValue = (bool)value;

            if (bValue)

                writer.WriteValue(arrBString[0]);

            else

                writer.WriteValue(arrBString[1]);

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

    public class Person

        [JsonConverter(typeof(BoolConvert))]

        public bool IsMarry { get; set; }

‘

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

十.全局序列化設置

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

　　Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();

   JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() =>

   {

　　　　//日期類型默認格式化處理

   　　setting.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;

      setting.DateFormatString = "yyyy-MM-dd HH:mm:ss";


　　　 //空值處理

      setting.NullValueHandling = NullValueHandling.Ignore;



      //高級用法九中的Bool類型轉換 設置

      setting.Converters.Add(new BoolConvert("是,否"));

      return setting;

});

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

回到頂部

總結

　　Newtonsoft.Json序列化庫替我們想了很多特性，也實現了很多特性，除了上面介紹的幾種高級用法外，還有其它的特殊用法，可以去官網進行學習。當然這裏我目前最喜歡的特性就是那個忽略部分屬性序列化的功能，很小的代碼改動實現了接口的優化，提升了用戶體驗。

Newtonsoft.Json，一款.NET中開源的Json序列化和反序列化類庫(下載地址http://json.codeplex.com/)。

下面是Json序列化和反序列化的簡單封裝：

/// <summary>

/// Json幫助類

/// </summary>

public class JsonHelper

{

/// <summary>

/// 將對象序列化爲JSON格式

/// </summary>

/// <param name="o">對象</param>

/// <returns>json字符串</returns>

public static string SerializeObject(object o)

{

string json = JsonConvert.SerializeObject(o);

return json;

}

/// <summary>

/// 解析JSON字符串生成對象實體

/// </summary>

/// <typeparam name="T">對象類型</typeparam>

/// <param name="json">json字符串(eg.{"ID":"112","Name":"石子兒"})</param>

/// <returns>對象實體</returns>

public static T DeserializeJsonToObject<T>(string json) where T : class

{

JsonSerializer serializer = new JsonSerializer();

StringReader sr = new StringReader(json);

object o = serializer.Deserialize(new JsonTextReader(sr), typeof(T));

T t = o as T;

return t;

}

/// <summary>

/// 解析JSON數組生成對象實體集合

/// </summary>

/// <typeparam name="T">對象類型</typeparam>

/// <param name="json">json數組字符串(eg.[{"ID":"112","Name":"石子兒"}])</param>

/// <returns>對象實體集合</returns>

public static List<T> DeserializeJsonToList<T>(string json) where T : class

{

JsonSerializer serializer = new JsonSerializer();

StringReader sr = new StringReader(json);

object o = serializer.Deserialize(new JsonTextReader(sr), typeof(List<T>));

List<T> list = o as List<T>;

return list;

}

/// <summary>

/// 反序列化JSON到給定的匿名對象.

/// </summary>

/// <typeparam name="T">匿名對象類型</typeparam>

/// <param name="json">json字符串</param>

/// <param name="anonymousTypeObject">匿名對象</param>

/// <returns>匿名對象</returns>

public static T DeserializeAnonymousType<T>(string json, T anonymousTypeObject)

{

T t = JsonConvert.DeserializeAnonymousType(json, anonymousTypeObject);

return t;

}

　　爲進一步理解Newtonsoft，寫了一些測試的例子：

/// <summary>

/// Json測試

/// </summary>

public class JsonTest : IRun

{

public void Run()

{

Student sdudent = new Student();

sdudent.ID = 1;

sdudent.Name = "陳晨";

sdudent.NickName = "石子兒";

sdudent.Class = new Class() { Name = "CS0216", ID = 0216 };

//實體序列化和反序列化

string json1 = JsonHelper.SerializeObject(sdudent);

//json1 : {"ID":1,"Name":"陳晨","NickName":"石子兒","Class":{"ID":216,"Name":"CS0216"}}

Student sdudent1 = JsonHelper.DeserializeJsonToObject<Student>(json1);

//實體集合序列化和反序列化

List<Student> sdudentList = new List<Student>() { sdudent, sdudent1 };

string json2 = JsonHelper.SerializeObject(sdudentList);

//json: [{"ID":1,"Name":"陳晨","NickName":"石子兒","Class":{"ID":216,"Name":"CS0216"}},{"ID":1,"Name":"陳晨","NickName":"石子兒","Class":{"ID":216,"Name":"CS0216"}}]

List<Student> sdudentList2 = JsonHelper.DeserializeJsonToList<Student>(json2);

//DataTable序列化和反序列化

DataTable dt = new DataTable();

dt.TableName = "Student";

dt.Columns.Add("ID", typeof(int));

dt.Columns.Add("Name");

dt.Columns.Add("NickName");

DataRow dr = dt.NewRow();

dr["ID"] = 112;

dr["Name"] = "戰三";

dr["NickName"] = "小三";

dt.Rows.Add(dr);

string json3 = JsonHelper.SerializeObject(dt);

//json3 : [{"ID":112,"Name":"戰三","NickName":"小三"}]

DataTable sdudentDt3 = JsonHelper.DeserializeJsonToObject<DataTable>(json3);

List<Student> sdudentList3 = JsonHelper.DeserializeJsonToList<Student>(json3);

//驗證對象和數組

Student sdudent4 = JsonHelper.DeserializeJsonToObject<Student>("{\"ID\":\"112\",\"Name\":\"石子兒\"}");

List<Student> sdudentList4 = JsonHelper.DeserializeJsonToList<Student>("[{\"ID\":\"112\",\"Name\":\"石子兒\"}]");

//匿名對象解析

var tempEntity = new { ID = 0, Name = string.Empty };

string json5 = JsonHelper.SerializeObject(tempEntity);

//json5 : {"ID":0,"Name":""}

tempEntity = JsonHelper.DeserializeAnonymousType("{\"ID\":\"112\",\"Name\":\"石子兒\"}", tempEntity);

var tempStudent = new Student();

tempStudent = JsonHelper.DeserializeAnonymousType("{\"ID\":\"112\",\"Name\":\"石子兒\"}", tempStudent);

Console.Read();

}

/// <summary>

/// 學生信息實體

/// </summary>

public class Student

{

public int ID { get; set; }

public string Name { get; set; }

public string NickName { get; set; }

public Class Class { get; set; }

}

/// <summary>

/// 學生班級實體

/// </summary>

public class Class

{

public int ID { get; set; }

public string Name { get; set; }

}

使用Json幫助類時，有兩點需要注意下：

1. 通常使用調用實體序列化SerializeObject()和反序列化DeserializeJsonToObject()兩個方法就可以了。但有些情況下我們解析json字符串時，可能沒有對應的實體類型（或者說不想添加對應的實體類），這時候可以用匿名對象解析方法DeserializeAnonymousType()，方便快捷，對應代碼如下：

//匿名對象解析

var tempEntity = new { ID = 0, Name = string.Empty };

string json5 = JsonHelper.SerializeObject(tempEntity);

//json5 : {"ID":0,"Name":""}

tempEntity = JsonHelper.DeserializeAnonymousType("{\"ID\":\"112\",\"Name\":\"石子兒\"}", tempEntity);

Console.WriteLine(tempEntity.ID + ":" + tempEntity.Name);

2. Json的兩種結構數組和對象解析時略有不同。Json對象一般轉換成實體，Json數組一般轉換成實體集合。代碼如下：

//驗證對象和數組

Student sdudent4 = JsonHelper.DeserializeJsonToObject<Student>("{\"ID\":\"112\",\"Name\":\"石子兒\"}");

List<Student> sdudentList4 = JsonHelper.DeserializeJsonToList<Student>("[{\"ID\":\"112\",\"Name\":\"石子兒\"}]");

簡單解釋下Json對象和數組的含義：

對象是以“{”（左括號）開始，“}”（右括號）結束。每個“名稱”後跟一個“:”（冒號）；“‘名稱/值’ 對”之間運用 “,”（逗號）分隔。名稱用引號括起來；值如果是字符串則必須用括號，數值型則不須要。例如：{"ID":"112","Name":"石子兒"}。

數組是值（value）的有序集合。一個數組以“[”（左中括號）開始，“]”（右中括號）結束。值之間運用 “,”（逗號）分隔。例如：[{"ID":"112","Name":"石子兒"},{"ID":"113","Name":"陳晨"}]。

Newtonsoft.Json Json.NET - Newtonsoft

Newtonsoft.Json介紹

基本用法

高級用法

總結

常用ShaderToonWater實現原理及實現

unsafe 嚮導文檔

How To Get Started With DOTS (第 1 篇)

Data-OrientedTechnologyStack(DOTS) 記錄及遇到的問題

unsafe 詳細文檔

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結