2013年6月27日 星期四

Json.Net 轉換IDictionary 介面

Json.Net 處理 IDictionary介面的方式,會解析成物件的key和value
以下是一個簡單的例子

// 淮備資料
Dictionary<string, string> dict1 = new Dictionary<string, string>()
{
    {"a", "1"},
    {"b", "2"},
    {"c", "3"},
};

// 序列化
string jsonString = JsonConvert.SerializeObject(dict1);
Console.WriteLine(jsonString);

// 反序列化
Dictionary<string, string> dict2 = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonString);
foreach (KeyValuePair<string, string> item in dict2)
{
    Console.WriteLine("key:{0}, value:{1}", item.Key, item.Value);
}

Console.ReadLine();

執行結果

Json.Net 轉換 IEnumerable 介面

Json.Net對於IEnumerable介面的處理,同樣是序列化成陣列的格式
首先先宣告個物件以便之後的處理

private class Person
{
    public int id { get; set; }
    public string name { get; set; }
    public DateTime date { get; set; }
}

轉換IEnumerable介面,以List為例
static void Main(string[] args)
{
    // 淮備資料
    List<Person> list1 = new List<Person>()
    {
        new Person()
        {
            id = 1,
            name = "p1",
            date = DateTime.Today.AddDays(-1)

        },
        new Person()
        {
            id = 2,
            name="p2",
            date = DateTime.Today
        },
        new Person()
        {
            id = 3,
            name = "p3",
            date = DateTime.Today.AddDays(1)
        }
    };

    // 序列化
    string jsonString = JsonConvert.SerializeObject(list1);
    Console.WriteLine(jsonString);

    // 反序列化
    List<Person> list2 = JsonConvert.DeserializeObject<List<Person>>(jsonString);
    foreach (var item in list2)
    {
        Console.WriteLine("id:{0}, name:{1}, date:{2}", item.id, item.name, item.date);
    }

    Console.ReadLine();
}

執行結果

Json.Net 用法

首先用最基本的JsonTextWriter和JsonTextReader
JsonTextWriter使用成對的方法來輸出Json字串
JsonTextReader使用Read方法來持續讀取Json字串
看得出來在使用上有點拖泥帶水
static void Main(string[] args)
{
    string jsonString = string.Empty;

    using (StringWriter sw = new StringWriter())
    {
        using (JsonTextWriter writer = new JsonTextWriter(sw))
        {
            // 開始輸出物件
            writer.WriteStartObject();

            // 輸出屬性:id
            writer.WritePropertyName("id");
            writer.WriteValue(1);

            // 輸出屬性:name
            writer.WritePropertyName("name");
            writer.WriteValue("xian");

            // 輸出屬性today
            writer.WritePropertyName("today");
            writer.WriteValue(DateTime.Today);

            // 開始輸出陣列
            writer.WritePropertyName("arraydata");
            writer.WriteStartArray();
            writer.WriteValue(1);
            writer.WriteValue(2);
            writer.WriteValue(3);

            // 結束輸出陣列
            writer.WriteEndArray();

            // 結束串出物件
            writer.WriteEndObject();
        }

        jsonString = sw.ToString();
        Console.WriteLine(jsonString);
    }

    using (StringReader sr = new StringReader(jsonString))
    {
        using (JsonTextReader reader = new JsonTextReader(sr))
        {
            while (reader.Read())
            {
                if (reader.Value != null)
                {
                    Console.WriteLine("token:{0}, value:{1}", reader.TokenType, reader.Value);
                }
                else
                {
                    Console.WriteLine("token:{0}", reader.TokenType);
                }
            }
        }
    }

    Console.ReadLine();
}

執行結果

使用JObject可以簡化一點
// 淮備Json資料
JObject obj1 = new JObject()
{
    new JProperty("id", 1),
    new JProperty("name", "xian"),
    new JProperty("today", DateTime.Today),
    new JProperty("arraydata", 
    new JArray()
    {
        new JValue(1),
        new JValue(2),
        new JValue(3),
    })
};

string jsonString = obj1.ToString();
Console.WriteLine(jsonString);

// 解析Json格式
JObject obj2 = JObject.Parse(jsonString);
Console.WriteLine(
    "id:{0}, name:{1}, today:{2}, arraydata:{3}",
    obj2["id"],
    obj2["name"],
    obj2["today"],
    obj2["arraydata"]);
Console.ReadLine();
執行結果

最常使用還是JsonConvert這一個方式,用法也很直覺

// 淮備資料
Person p1 = new Person()
{
    id = 1,
    name = "xian",
    today = DateTime.Today
};

// 序列化物件
string jsonString = JsonConvert.SerializeObject(p1);
Console.WriteLine("jsonstring:{0}", jsonString);

// 反序列化物件
Person p2 = JsonConvert.DeserializeObject<Person>(jsonString);
Console.WriteLine("id:{0}, name:{1}, today:{2}", p2.id, p2.name, p2.today);

Console.ReadLine();
執行結果

Json.Net 介紹

Json.Net 是一個第三方套件,其強大的功能和.Net內建的比較表,可以去官網看一下
個人比較有感覺的差別是
  • 支援.Net 2.0
  • 支援LINQ  
  • 支援暱名類別
  • 支援dynamic物件
  • 日期格式為ISO8601
該專案為Open Source,可以到codeplex下載原始碼
安裝的方式也很簡單,打開NuGet輸入Json.Net就行了
Json.Net也有完整的線上文件可以參考

以下是Json.Net常用的物件

JsonConvert 最容易使用的一個靜態工具類別
JsonTextReader 讀取Json格式
JsonTextWriter 輸出Json格式
JObject 對應Json物件,就是大括號包起來的部份
JArray 對應Json陣列,就是中括號包起來的部份
JValue 對應Json值的部份

2013年6月20日 星期四

DataContractJsonSerializer 日期處理

使用DataContractJsonSerializer序列化日期時,格式為\/Date(ticks+時區資料)\/這個樣子
因為有時區資料,所以不用像JavaScriptSerializer一樣還要手動加上ToLocalTime函式
// 初始化DataContractJsonSerializer類別
DateTime d1 = DateTime.Now;
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(DateTime));
string jsonString = string.Empty;

// 序列化資料
using (MemoryStream ms = new MemoryStream())
{
    dcjs.WriteObject(ms, d1);
    jsonString = Encoding.UTF8.GetString(ms.ToArray());
    Console.WriteLine(jsonString);
    Console.WriteLine();
}

// 反序列化資料
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)))
{
    DateTime d2 = (DateTime)dcjs.ReadObject(ms);
    Console.WriteLine("d1:{0}, kind:{1}", d1, d1.Kind);
    Console.WriteLine("d2:{0}, kind:{1}", d2, d2.Kind);
}

Console.ReadLine();

執行結果

使用JavaScript處理的時後,因為多了時區資料,所以reg要修改一下
打開一個Chrome的主控台並輸入以下幾行指令
// 建立一個JSON格式的資料
data = { "today": "\/Date(1371716206301+0800)\/"};

// 看一下資料解析的樣子
data.today;
 
// 把前後的斜線去掉的樣子
data.today.replace(/\//g, "");
 
// 使用eval來得到日期
eval("new " + data.today.replace(/\//g, ""))
 
// 使用reg取出ticks的部份
data.today.replace(/\/Date\((.*?)\)\//g, "$1");
 
// parseInt轉成數字後也能得到日期
new Date(parseInt(data.today.replace(/\/Date\((.*?)\)\//g, "$1")))
執行結果如下

DataContractJsonSerializer 轉換 IDictionary 介面

轉換IDictionary介面的方式也一樣,只要注意初始化DataContractJsonSerializer類別時傳入IDictionary介面就好
但是輸出的結果並不如預期中為物件的格式
直接宣告一個Dictionary來當範例
// 淮備序列化的類別資料
Dictionary<int, object> dataList = new Dictionary<int, object>()
{
    {1, "a"},
    {2, "b"},
    {3, "c"}
};

初始化時要傳入這個Dictionary的型別
// 初始化DataContractJsonSerializer類別
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(Dictionary<int, object>));
string jsonString = string.Empty;

序列化的方式一樣
// 序列化資料
using (MemoryStream ms = new MemoryStream())
{
    dcjs.WriteObject(ms, dataList);
    jsonString = Encoding.UTF8.GetString(ms.ToArray());
    Console.WriteLine(jsonString);
    Console.WriteLine();
}

反序列化的方式也一樣
// 反序列化資料
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)))
{
    Dictionary<int, object> data2List = dcjs.ReadObject(ms) as Dictionary<int, object>;
    foreach (KeyValuePair<int, object> item in data2List)
    {
        Console.WriteLine(
            "Key:{0}, Value:{1}",
            item.Key,
            item.Value);
    }
}

執行結果可以看到序列化成JSON字串時,會固定變成Key:xx, Value:oo的陣列
這在不同JSON元件之間的轉換會造成一些問題

DataContractJsonSerializer 轉換 IEnumerable 介面

轉換IEnumerable的用法和一般的資料沒什麼不同
差別只在於初始化類別的時後,傳入的資料型別也要改成IEnumerable
宣告一個相同的資料型別來做範例
[DataContract]
public class JsonData
{
    [DataMember(Name = "ID", Order = 0)]
    public int Id { get; set; }

    [DataMember(Order = 1)]
    public string Name { get; set; }

    [DataMember(Order = 2)]
    public DateTime Today { get; set; }

    [DataMember(Order=3)]
    public bool IsBool { get; set; }

    [IgnoreDataMember()]
    public string UnlessField { get; set; }
}

準備一個List來當做序列化的資料
初始化DataContractJsonSerializer類別的時後,也要傳入這個List的型別
// 淮備序列化的類別資料
List<JsonData> dataList = new List<JsonData>()
{
    new JsonData()
    {
        Id = 1,
        Name = "data1",
        Today = DateTime.Now.AddDays(-1),
        IsBool = true,
        UnlessField = "沒用到的欄位1"
    },
    new JsonData()
    {
        Id = 2,
        Name = "data2",
        Today = DateTime.Now,
        IsBool = false,
        UnlessField = "沒用到的欄位2"
    },
    new JsonData()
    {
        Id = 3,
        Name = "data3",
        Today = DateTime.Now.AddDays(1),
        IsBool = true,
        UnlessField = "沒用到的欄位3"
    }

};

// 初始化DataContractJsonSerializer類別
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(List<JsonData>));
string jsonString = string.Empty;

序列化的方法一樣
// 序列化資料
using (MemoryStream ms = new MemoryStream())
{
    dcjs.WriteObject(ms, dataList);
    jsonString = Encoding.UTF8.GetString(ms.ToArray());
    Console.WriteLine(jsonString);
    Console.WriteLine();
}

反序列化的方法也一樣
// 反序列化資料
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)))
{
    List<JsonData> data2List = dcjs.ReadObject(ms) as List<JsonData>;
    foreach (JsonData item in data2List)
    {
        Console.WriteLine(
            "Id:{0}, Name:{1}, Today:{2}, IsBool:{3}, UnlessField:{4}",
            item.Id,
            item.Name,
            item.Today,
            item.IsBool,
            item.UnlessField);
    }
}

執行結果資料一樣序列化成陣列的樣子,反序列化也沒什麼問題

DataContractJsonSerializer 用法

首先需要先定義資料類別
DataContract用來標記類別
DataMember用來標記屬性,Name可以用來變更序列化後的名稱,Order則是序列化的順序
IgnoreDataMember用來標記屬性,表示不參與序列化過程
[DataContract]
public class JsonData
{
    [DataMember(Name = "ID", Order = 0)]
    public int Id { get; set; }

    [DataMember(Order = 1)]
    public string Name { get; set; }

    [DataMember(Order = 2)]
    public DateTime Today { get; set; }

    [DataMember(Order=3)]
    public bool IsBool { get; set; }

    [IgnoreDataMember()]
    public string UnlessField { get; set; }
}

初始化DataContractJsonSerializer類別時,需傳入要序列化的資料型別
// 淮備序列化的類別資料
JsonData d1 = new JsonData()
{
    Id = 1,
    Name = "data",
    Today = DateTime.Now,
    IsBool = true,
    UnlessField = "沒用到的欄位"
};

// 初始化DataContractJsonSerializer類別
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(JsonData));
string jsonString = string.Empty;

序列化資料使用WriteObject寫入Stream
再用Encoding取得json字串
// 序列化資料
using (MemoryStream ms = new MemoryStream())
{
    dcjs.WriteObject(ms, d1);
    jsonString = Encoding.UTF8.GetString(ms.ToArray());
    Console.WriteLine(jsonString);
}

反序列化資料先用Encoding取得取得Byte Array讀入Stream
再用ReadObject讀出資料型別
// 反序列化資料
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)))
{
    JsonData d2 = dcjs.ReadObject(ms) as JsonData;
    Console.WriteLine(
        "Id:{0}, Name:{1}, Today:{2}, IsBool:{3}, UnlessField:{4}",
        d2.Id,
        d2.Name,
        d2.Today,
        d2.IsBool,
        d2.UnlessField);
}

執行結果如下
1. 日期的部份加入了時區的資料,所以反序列化回來後不用再手動加上ToLocalTime函數
2.  標記為IgnoreDataMember的欄位並沒有參考序列化的過程,反序列化回來後是空字串

DataContractJsonSerializer 介紹

JavaScriptSerializer是.NET 3.5中新增的類別
該類別在System.Runtime.Serialization.Json命名空間下面
需引用System.Runtime.Serialization.dll
建構式
DataContractJsonSerializer(Type) 傳入要轉換的資料型別
DataContractJsonSerializer(Type, DataContractJsonSerializerSettings) 傳入要轉換的資料型別,和設定值

方法
WriteObject
將物件序列化成JSON字串
ReadObject
將JSON字串反序列化成指定的物件

2013年6月19日 星期三

JavaScriptSerializer ScriptIgnoreAttribute

ScriptIgnore這個Attribute是用來取消屬性或欄位的序列化

using System;
using System.Web.Script.Serialization;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string jsonString = string.Empty;
            Data data = new Data()
            {
                Id = 1,
                Name = "data"
            };

            JavaScriptSerializer jss = new JavaScriptSerializer();
            jsonString = jss.Serialize(data);
            Console.WriteLine(jsonString);
            Console.ReadLine();
        }

        private class Data
        {
            public int Id { get; set; }
            public string Name { get; set; }
        }
    }
}

執行結果如下

加上ScriptIgnore這個Attribute之後
using System;
using System.Web.Script.Serialization;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string jsonString = string.Empty;
            Data data = new Data()
            {
                Id = 1,
                Name = "data"
            };

            JavaScriptSerializer jss = new JavaScriptSerializer();
            jsonString = jss.Serialize(data);
            Console.WriteLine(jsonString);
            Console.ReadLine();
        }

        private class Data
        {
            public int Id { get; set; }

            [ScriptIgnore]
            public string Name { get; set; }
        }
    }
}
執行結果如下



JavaScriptSerializer 日期處理

使用JavaScriptSerializer序列化日期時,格式會長的像\/Date(ticks)\/這個樣子
其中的tick為1970/1/1到目前為止的毫秒數
因為沒有時區資訊,而且預設會轉換成UTC時間
所以反序列化回來的時後,會有時區的問題
string jsonString = string.Empty;
DateTime d1 = DateTime.Now;

JavaScriptSerializer jss = new JavaScriptSerializer();
jsonString = jss.Serialize(d1);
Console.WriteLine(jsonString);

DateTime d2 = jss.Deserialize<DateTime>(jsonString);
Console.WriteLine("d1:{0}, kind:{1}", d1, d1.Kind);
Console.WriteLine("d2:{0}, kind:{1}", d2, d2.Kind);
Console.ReadLine();
執行結果如下
解決方法很簡單,反序列化回來的時後,記得把時間ToLocalTime就好了
string jsonString = string.Empty;
DateTime d1 = DateTime.Now;

JavaScriptSerializer jss = new JavaScriptSerializer();
jsonString = jss.Serialize(d1);
Console.WriteLine(jsonString);

DateTime d2 = jss.Deserialize<DateTime>(jsonString).ToLocalTime();
Console.WriteLine("d1:{0}, kind:{1}", d1, d1.Kind);
Console.WriteLine("d2:{0}, kind:{1}", d2, d2.Kind);
Console.ReadLine();
執行結果如下

另外一個問題是傳到JavaScript的時後,只會把這樣的格式當成字串,需要自行拆解
打開一個Chrome的主控台來測試一下,輸入以下幾行指令
// 建立一個JSON格式的資料
data = { "today": "\/Date(1371631612818)\/" };

// 看一下資料解析的樣子
data.today;

// 把前後的斜線去掉的樣子
data.today.replace(/\//g, "");

// 使用eval來得到日期
eval("new " + data.today.replace(/\//g, ""))

// 使用reg取出ticks的部份
data.today.replace(/\/Date\((\d+)\)\//g, "$1");

// parseInt轉成數字後也能得到日期
new Date(parseInt(data.today.replace(/\/Date\((\d+)\)\//g, "$1")))
執行結果如下

2013年6月18日 星期二

JavaScriptSerializer 轉換 IDictionary 介面

一樣開個新的Console專案,和加入System.Web.Extensions.dll參考
完整的程式碼如下
using System;
using System.Collections.Generic;
using System.Web.Script.Serialization;

namespace JavaScriptSerializerDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // 淮備要序列化的資料
            Dictionary<string, object> data = new Dictionary<string, object>()
            {
                {
                    "ID", 1
                },
                {
                    "Name", "Dictionary Demo"
                },
                {
                    "State", EnumState.c
                },
                {
                    "Date", DateTime.Today
                },
                {
                    "Guid", Guid.NewGuid()
                }
            };

            // 序列化
            JavaScriptSerializer jss = new JavaScriptSerializer();
            string jsonString = jss.Serialize(data);
            Console.WriteLine("序列化的JSON字串:{0}\r\n", jsonString);

            // 反序列化
            JsonObject obj = jss.Deserialize<JsonObject>(jsonString);
            Console.WriteLine(
                "反序列化後的物件, ID:{0}, Name:{1}, State:{2}, Date:{3}, GUID:{4}\r\n",
                obj.ID,
                obj.Name,
                obj.State,
                obj.Date,
                obj.GUID);

            
            Dictionary<string, object> dict = jss.Deserialize<Dictionary<string, object>>(jsonString);
            Console.WriteLine("反序列化回Dictionary");
            foreach (var key in dict.Keys)
            {
                Console.WriteLine("Key:{0}, Value:{1}", key, dict[key]);
            }

            Console.ReadLine();
        }

        /// <summary>
        /// 要序列化的資料類別
        /// </summary>
        private class JsonObject
        {
            public int ID { get; set; }
            public string Name { get; set; }
            public EnumState State { get; set; }
            public DateTime Date { get; set; }
            public Guid GUID { get; set; }
        }

        /// <summary>
        /// 狀態列舉
        /// </summary>
        public enum EnumState
        {
            a = 0,
            b = 1,
            c = 2
        }
    }
}


序列化後的JSON
{
  "ID": 1,
  "Name": "Dictionary Demo",
  "State": 2,
  "Date": "\/Date(13714 84800000)\/",
  "Guid": "7c52f0a4-a742-4898-a55c-583ab851b183"
}

輸出的結果

JavaScriptSerializer 轉換 IEnumerable 介面

一樣開新Console專案做示範,並加入System.Web.Extensions.dll參考
完整的程式碼如下
using System;
using System.Collections.Generic;
using System.Web.Script.Serialization;

namespace JavaScriptSerializerDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // 淮備要序列化的資料
            List<JsonObject> data = new List<JsonObject>()
            {
                new JsonObject()
                {
                    ID = 1,
                    Name = "JsonObject1",
                    State = EnumState.a,
                    Date = DateTime.Today.AddDays(-1),
                    GUID = Guid.NewGuid()
                },
                new JsonObject()
                {
                    ID = 2,
                    Name = "JsonObject2",
                    State = EnumState.b,
                    Date = DateTime.Today,
                    GUID = Guid.NewGuid()
                },
                new JsonObject()
                {
                    ID = 3,
                    Name = "JsonObject3",
                    State = EnumState.c,
                    Date = DateTime.Today.AddDays(1),
                    GUID = Guid.NewGuid()
                },
            };

            // 序列化
            JavaScriptSerializer jss = new JavaScriptSerializer();
            string jsonString = jss.Serialize(data);
            Console.WriteLine("序列化的JSON字串:{0}\r\n", jsonString);

            // 反序列化
            List<JsonObject> obj = jss.Deserialize<List<JsonObject>>(jsonString);
            foreach (var item in obj)
            {
                Console.WriteLine(
                    "反序列化後的物件, ID:{0}, Name:{1}, State:{2}, Date:{3}, GUID:{4}",
                    item.ID,
                    item.Name,
                    item.State,
                    item.Date,
                    item.GUID);
            }

            Console.ReadLine();
        }

        /// <summary>
        /// 要序列化的資料類別
        /// </summary>
        private class JsonObject
        {
            public int ID { get; set; }
            public string Name { get; set; }
            public EnumState State { get; set; }
            public DateTime Date { get; set; }
            public Guid GUID { get; set; }
        }

        /// <summary>
        /// 狀態列舉
        /// </summary>
        public enum EnumState
        {
            a = 0,
            b = 1,
            c = 2
        }
    }
}

序列化後的結果
[
  {
    "ID": 1,
    "Name": "JsonObject1",
    "State": 0,
    "Date": "\/Date(13713984 00000)\/",
    "GUID": "97eff121-b03d-4c76-9d18-1a82660f3f40"
  },
  {
    "ID": 2,
    "Name": "JsonObject2",
    "State": 1,
    "Date": "\/Date(1371484800000)\/",
    "GUID": "2fa2f230-d721-4c21-9630 -a90657bb4aac"
  },
  {
    "ID": 3,
    "Name": "JsonObject3",
    "State": 2,
    "Date": "\/Date(1371571200 000)\/",
    "GUID": "e8a8462f-7c59-4f34-a895-484f2be13bd7"
  }
]
執行的結果

JavaScriptSerializer 用法

首先開一個Console專案
加入System.Web.Extensions.dll的引用
完整的程式碼如下
using System;
using System.Web.Script.Serialization;

namespace JavaScriptSerializerDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // 淮備要序列化的資料
            JsonObject data = new JsonObject()
            {
                ID = 1,
                Name = "JsonObject",
                State = EnumState.c,
                Date = DateTime.Today,
                GUID = Guid.NewGuid()
            };

            // 序列化
            JavaScriptSerializer jss = new JavaScriptSerializer();
            string jsonString = jss.Serialize(data);
            Console.WriteLine("序列化的JSON字串:{0}\r\n", jsonString);

            // 反序列化
            JsonObject obj = jss.Deserialize<JsonObject>(jsonString);
            Console.WriteLine(
                "反序列化後的物件, ID:{0}, Name:{1}, State:{2}, Date:{3}, GUID:{4}",
                obj.ID,
                obj.Name,
                obj.State,
                obj.Date,
                obj.GUID);

            Console.ReadLine();
        }

        /// <summary>
        /// 要序列化的資料類別
        /// </summary>
        private class JsonObject
        {
            public int ID { get; set; }
            public string Name { get; set; }
            public EnumState State { get; set; }
            public DateTime Date { get; set; }
            public Guid GUID { get; set; }
        }

        /// <summary>
        /// 狀態列舉
        /// </summary>
        public enum EnumState
        {
            a = 0,
            b = 1,
            c = 2
        }
    }
}
序列化的JSON字串
{
  "ID": 1,
  "Name": "JsonObject",
  "State": 2,
  "Date": "\/Date(1371484800 000)\/",
  "GUID": "80d39299-a127-459f-b6ef-55626c490f80"
}

執行的結果

JavaScriptSerializer 介紹

JavaScriptSerializer是.NET 3.5中新增的類別
該類別在System.Web.Script.Serialization命名空間下面
需引用System.Web.Extensions.dll

方法
Serialize 將物件序列化成JSON字串
Deserialize<T> 將JSON字串反序列化成指定的物件


屬性
MaxJsonLength 取得或設定可接受的字串最大長度,預設為4MB
RecursionLimit 取得或設定要處理物件層級數目的限制

參考資料

System.Web.Script.Serialization 命名空間

JSON筆記

JSON 筆記

JSON的全名為JavaScript Object Notation,是JavaScript的物件表示法
因為輕量化,易於人閱讀和編寫,也易於機器解析和生成的關系,所以很容易在各種網絡平台和程序之間做為一種資料交換格式

JSON的內容主要有二種型態,一種是物件,一種是陣列
物件由大括號包起來,屬性和值用冒號來分隔,每個屬性之間用逗點分隔
陣列用中括號包起來,每個資料之間用逗點分隔
{
  "ID": 1,
  "Name": "JSON Demo",
  "State": 2,
  "Date": "\/Date(13714 84800000)\/",
  "Guid": "7c52f0a4-a742-4898-a55c-583ab851b183",
  "DataList": [
    1,
    2,
    3,
    4,
    5
  ]
}

JSON的資料型態有文字、數字、布林、NULL
文字:用雙引號包起來的內容
數字:包含整數和浮點數
布林: true / false
更多完整的介紹,可以參考官網或W3CSchool

JSON官網介紹

W3CSchool Learn JSON


在.NET中內建兩種解析方式,但需要Framework 3.5以上

System.Web.Extensions下面的JavaScriptSerializer
JavaScriptSerializer 介紹
JavaScriptSerializer 用法
JavaScriptSerializer 轉換 IEnumerable 介面
JavaScriptSerializer 轉換 IDictionary 介面
JavaScriptSerializer 日期處理
JavaScriptSerializer ScriptIgnoreAttribute



System.Runtime.Serialization下面的DataContractJsonSerializer
DataContractJsonSerializer 介紹
DataContractJsonSerializer 用法
DataContractJsonSerializer 轉換 IEnumerable 介面
DataContractJsonSerializer 轉換 IDictionary 介面
DataContractJsonSerializer 日期處理



另外還有一個好用的第三方套件JSON.Net
Json.Net 介紹
Json.Net 用法
Json.Net 轉換 IEnumerable 介面
Json.Net 轉換 IDictionary 介面
Json.Net 日期處理



另外介紹幾個好用的工具
Online JSON Viewer
一個用來方便格式化JSON字串的網站

JSON2CSharp
一個用來產生C#對應類別的網站

JSON C# Class Generator
一個用來產生C#對應類別的程式

JSONLint - The JSON Validator