準備好飲料，咱們一塊兒來玩玩JSON，什麼是Json：一種數據表示形式，JSON：JavaScript Object Notation對象表示法
Json語法規則：javascript
-
數據在鍵值對中
-
數據由逗號分隔
-
花括號保存對象
-
方括號保存數組
1、JSON的表現形式
在javascript中對象的表現形式以下 php
1.對象表現形式： html
<script type="text/javascript">
var jsonObject={code:0,resultmsg:'成功'};
alert(jsonObject.code);
</script>
2.數組表現形式： java
<script type="text/javascript">
var personInfo=[
{name:'張三',Age:18,sex:'男'},
{name:'小倩',Age:19,sex:'女'},
{name:'小明',Age:18,sex:'男'}
];
alert(personInfo[0].name);
</script>
3.對象數組聯合表現形式： 面試
<script type="text/javascript">
var Studennt=[
{name:'張三',Age:18,sex:'男',succes:[
{name:'語文',succ:89.5},
{name:'數學',succ:89.5},
{name:'外語',succ:89.5}
]
},
{name:'小倩',Age:19,sex:'女',succes:[
{name:'語文',succ:89.5},
{name:'數學',succ:89.5},
{name:'外語',succ:89.5}
]},
{name:'小明',Age:18,sex:'男',succes:[
{name:'語文',succ:89.5},
{name:'數學',succ:89.5},
{name:'外語',succ:89.5}
]}
];
alert(Studennt[0].name);
</script>
2、什麼是JSON序列化與反序列化？
序列化是將對象狀態轉換爲可保持或傳輸的格式的過程。與序列化相對的是反序列化，它將流轉換爲對象。這兩個過程結合起來，能夠輕鬆地存儲和傳輸數據。
簡單來講就是對象轉換成爲JSON格式字符串咱們稱爲序列化，反之JSON字符串轉換爲對象咱們稱爲反序列化。
下邊咱們準備點基礎類，部門信息類
using System;
namespace MySerialize.Entity
{
public class DeptInfo
{
public int Id { get; set; }
public string DeptName { get; set; }
public DateTime CreateTime { get; set; }
}
}
枚舉類，分別是職務類別，人員狀態。這裏簡單說下枚舉的特色是若是枚舉值不指定起始位置默認從0開始，若是指定枚舉第一個值則從指定的第一位開始一次遞增長一計算枚舉值，若是每一個枚舉值都賦值則按賦值計算，
不理解這句話不要緊不影響學習JSON正反序列化。
using System;
namespace MySerialize.Entity
{
/// <summary>
/// 職務類別
/// </summary>
public enum JobType
{
董事長,
總經理,
總監,
部門經理,
人事專員,
職員,
工程師,
其餘
}
public enum PersonType
{
在職,離職,退休,停職
}
}
用戶信息類
using System;
using System.Collections.Generic;
namespace MySerialize.Entity
{
public class UserInfo
{
public int Id { get; set; }
public string UserName { get; set; }
/// <summary>
/// 姓
/// </summary>
public string FirstName { get; set; }
/// <summary>
/// 名
/// </summary>
public string LastName { get; set; }
public string PassWord { get; set; }
public string Phone { get; set; }
public string Address { get; set; }
public DeptInfo Dept { get; set; }
public JobType DeptType { get; set; }
public PersonType UserType { get; set; }
/// <summary>
/// 職業技能
/// </summary>
public Dictionary<int, string> UserSkill { get; set; }
/// <summary>
/// 特長
/// </summary>
public Dictionary<string, string> UserStrong { get; set; }
}
}
數據初始化類
using MySerialize.Entity;
using System;
using System.Collections.Generic;
namespace MySerialize
{
public class DataFactory
{
/// <summary>
/// 獲取全部專業技能
/// </summary>
/// <returns></returns>
public static Dictionary<int, string> GetSkillAll() {
Dictionary<int, string> DictionarySkill = new Dictionary<int, string>();
DictionarySkill.Add(1, "1234");
DictionarySkill.Add(2, "abcd");
DictionarySkill.Add(3, "大中國");
DictionarySkill.Add(4, "學習");
DictionarySkill.Add(5, "上網");
return DictionarySkill;
}
/// <summary>
/// 獲取全部的特長
/// </summary>
/// <returns></returns>
public static Dictionary<string, string> GetStrongAll()
{
Dictionary<string, string> DictionaryStrong = new Dictionary<string, string>();
DictionaryStrong.Add("1", "abcdefg");
DictionaryStrong.Add("2", "abcdefg123");
DictionaryStrong.Add("3", "tvbcd");
DictionaryStrong.Add("4", "您吃了嗎");
DictionaryStrong.Add("5", "吃了嗎您呢");
DictionaryStrong.Add("6", "tvbc 早上好");
DictionaryStrong.Add("7", "vbbc 晚上好");
return DictionaryStrong;
}
public static List<UserInfo> BuildUserList()
{
DeptInfo dept0 = new DeptInfo() { CreateTime = DateTime.Now, DeptName = "開發部", Id = 1 };
DeptInfo dept1 = new DeptInfo() { CreateTime = DateTime.Now, DeptName = "電商事業部", Id = 2 };
DeptInfo dept2 = new DeptInfo() { CreateTime = DateTime.Now, DeptName = "成功部", Id = 3 };
DeptInfo dept3 = new DeptInfo() { CreateTime = DateTime.Now, DeptName = "人力資源管理部", Id = 4 };
List<UserInfo> list = new List<UserInfo>();
list.Add(new UserInfo()
{
Address = "北京昌平",
DeptType = JobType.工程師,
Dept = dept0,
Id = 1,
FirstName = "張",
LastName = "三",
PassWord = "",
Phone = "13122222222222",
UserName = "wbc",
UserType = PersonType.在職,
UserSkill = GetSkillAll(),
UserStrong = GetStrongAll()
});
list.Add(new UserInfo()
{
Address = "北京昌平",
DeptType = JobType.工程師,
Dept = dept0,
Id = 5,
FirstName = "張",
LastName = "三",
PassWord = "",
Phone = "13122222222222",
UserName = "wbc",
UserType = PersonType.在職,
UserSkill = GetSkillAll(),
UserStrong = GetStrongAll()
});
list.Add(new UserInfo()
{
Address = "北京昌平",
DeptType = JobType.工程師,
Dept = dept3,
Id = 3,
FirstName = "張",
LastName = "三",
PassWord = "",
Phone = "13122222222222",
UserName = "wbc",
UserType = PersonType.在職,
UserSkill = GetSkillAll(),
UserStrong = GetStrongAll()
});
list.Add(new UserInfo()
{
Address = "北京昌平",
DeptType = JobType.工程師,
Dept = dept2,
Id = 2,
FirstName = "wwdd",
LastName = "三",
PassWord = "",
Phone = "13122222222222",
UserName = "wbc",
UserType = PersonType.在職,
UserSkill = GetSkillAll(),
UserStrong = GetStrongAll()
});
list.Add(new UserInfo()
{
Address = "北京昌平",
DeptType = JobType.工程師,
Dept = dept1,
Id = 4,
FirstName = "wang",
LastName = "三",
PassWord = "",
Phone = "13122222222222",
UserName = "wbc",
UserType = PersonType.在職,
UserSkill = GetSkillAll(),
UserStrong = GetStrongAll()
});
return list;
}
}
}
3、常見Json序列化和反序列化類
1.DataContractJsonSerializer 類序列化和反序列化：sql
DataContractJsonSerializer 類在 System.Runtime.Serialization.Json這個命名空間下，在net 4.0裏面，而這個命名空間在 System.Runtime.Serialization.dll中typescript
List<UserInfo> list= DataFactory.BuildUserList();//獲取基礎數據
//對象的系列化
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(List<UserInfo>));
MemoryStream ms = new MemoryStream();
ser.WriteObject(ms, list);
string jsonString = Encoding.UTF8.GetString(ms.ToArray());
ms.Close();
//反序列化
ser = new DataContractJsonSerializer(typeof(List<UserInfo>));
ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
List<UserInfo> obj = (List<UserInfo>)ser.ReadObject(ms);
2.JavaScriptSerializer 類序列化和反序列化：編程
JavaScriptSerializer 類在 System.Web.Script.Serialization命名空間下了，在net3.0裏面,而這個命名空間在 System.Web.Extensions.dll 中json
Dictionary<string, string> dictionaryStrong= new Dictionary<string, string>();
dictionaryStrong.Add("1","22222222222222");
UserInfo user = new UserInfo() {
Id=1,
Dept =new DeptInfo() { CreateTime=DateTime.Now,Id=1,DeptName="開發部"},
Address="北京北京市",
DeptType=JobType.工程師,
FirstName="王",
LastName="柏成",
PassWord="",
Phone="13126994771",
UserName="wbc",
UserSkill=null,
UserStrong= dictionaryStrong,
UserType=PersonType.在職
};
//序列化
System.Web.Script.Serialization.JavaScriptSerializer jss = new System.Web.Script.Serialization.JavaScriptSerializer();
string jsonString = jss.Serialize(user);
txtData.Text = jsonString;
//反序列化
UserInfo obj = jss.Deserialize<UserInfo>(jsonString);
3.JsonConvert類序列化和反序列化：小程序
JsonConvert類在 Newtonsoft.Json 命名空間下了，而這個命名空間在Newtonsoft.Json.dll 中，而這個dll 只是第三方的一箇中間件，咱們能夠經過nuget 獲取並引用。
List<UserInfo> list = DataFactory.BuildUserList();//獲取基礎數據
//對象的系列化
string jsonString= JsonConvert.SerializeObject(list);
txtData.Text = jsonString;
//反序列化
List<UserInfo> obj = JsonConvert.DeserializeObject<List<UserInfo>>(jsonString);
4. 簡單學習 linq to Json：
linq to Json 是在Newtonsoft.Json.dll 的 Newtonsoft.Json.linq 命名空間下. json 操做類以下
| className(類名) | describe（說明） |
JObject |
用於操做JSON對象 |
JArray |
用語操做JSON數組 |
JValue |
表示數組中的值 |
JProperty |
表示對象中的屬性,以"key/value"形式 |
JToken |
用於存放Linq to JSON查詢後的結果 |
建立Json對象和數組組合：
JArray jArray = new JArray();
JObject staff = new JObject();
staff.Add(new JProperty("Name", "wangbaicheng"));
staff.Add(new JProperty("Age", 33));
staff.Add(new JProperty("Department", "銷售部"));
staff.Add(new JProperty("Leader", new JObject(new JProperty("Name", "feifei"), new JProperty("Age", 30), new JProperty("Department", "chanpin"))));
jArray.Add(staff);
jArray.Add(staff);
jArray.Add(staff);
staff.Add(new JProperty("Array", jArray));
jArray = new JArray();
jArray.Add(new JValue("1"));
jArray.Add(new JValue("2"));
jArray.Add(new JValue("3"));
jArray.Add(new JValue("4"));
staff.Add(new JProperty("arr", jArray));
txtData.Text = staff.ToString();
咱們還能夠經過如字符串獲取Json 對象，具體不演示了，看以下表格
| 方法 | 說明 |
JObject.Parse(string json) |
json含有JSON對象的字符串，返回爲JObject對象，最外層是對象 |
JObject.FromObject(object o) |
o爲要轉化的對象，返回一個JObject對象 |
JObject.Load(JsonReader reader) |
reader包含着JSON對象的內容，返回一個JObject對象 |
JArray.Parse(string json) |
json含有JSON數組的字符串，返回爲JArray對象，最外層是數組 |
JArray.FromObject(object o) |
o爲要轉化的對象，返回一個JArray對象 |
JArray.Load(JsonReader reader) |
reader包含着JSON對象的內容，返回一個JArray對象 |
現有以下Json
{\"Name\":\"wangbaicheng\",\"Age\":33,\"Department\":\"銷售部\",\"Leader\":{\"Name\":\"feifei\",\"Age\":30,\"Department\":\"chanpin\"},\"Array\":[{\"Name\":\"wangbaicheng\",\"Age\":33,\"Department\":\"銷售部\",\"Leader\":{\"Name\":\"feifei\",\"Age\":30,\"Department\":\"chanpin\"}},{\"Name\":\"wangbaicheng\",\"Age\":33,\"Department\":\"銷售部\",\"Leader\":{\"Name\":\"feifei\",\"Age\":30,\"Department\":\"chanpin\"}},{\"Name\":\"wangbaicheng\",\"Age\":33,\"Department\":\"銷售部\",\"Leader\":{\"Name\":\"feifei\",\"Age\":30,\"Department\":\"chanpin\"}}],\"arr\":[\"1\",\"2\",\"3\",\"4\"]}
咱們來看下使用linq 和使用對象來解析Json
//對象解析json和linq 解析json
{
string json = "{\"Name\":\"wangbaicheng\",\"Age\":33,\"Department\":\"銷售部\",\"Leader\":{\"Name\":\"feifei\",\"Age\":30,\"Department\":\"chanpin\"},\"Array\":[{\"Name\":\"wangbaicheng\",\"Age\":33,\"Department\":\"銷售部\",\"Leader\":{\"Name\":\"feifei\",\"Age\":30,\"Department\":\"chanpin\"}},{\"Name\":\"wangbaicheng\",\"Age\":33,\"Department\":\"銷售部\",\"Leader\":{\"Name\":\"feifei\",\"Age\":30,\"Department\":\"chanpin\"}},{\"Name\":\"wangbaicheng\",\"Age\":33,\"Department\":\"銷售部\",\"Leader\":{\"Name\":\"feifei\",\"Age\":30,\"Department\":\"chanpin\"}}],\"arr\":[\"1\",\"2\",\"3\",\"4\"]}";
JObject jObject = JObject.Parse(json);
//使用對象解析
string name= jObject["Name"].ToString();//注意大小寫
name = jObject.Value<string>("Name");//注意大小寫
JArray array= jObject.Value<JArray>("Array");
for (int i = 0; i < array.Count; i++)
{
JToken token= array[i];
JObject obj = token as JObject;
Console.WriteLine("對象解析"+obj.Value<string>("Name"));
}
//linq 解析
var names = from staff in jObject["Array"].Children()
select (string)staff["Name"];
foreach (var n in names)
Console.WriteLine("linq解析"+n);
}
這裏就不過多的深刻了，畢竟咱們大多數的時候仍是比較喜歡json 轉換成爲咱們本身定義的對象的。
4、封裝本身的JsonHelper 類
public static class JsonHelper
{
#region System.Runtime.Serialization net 4.0
/// <summary>
/// 對象序列化爲JSON
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="_t"></param>
/// <returns></returns>
public static string ObjectToJson<T>(this T _t)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
MemoryStream ms = new MemoryStream();
ser.WriteObject(ms, _t);
string jsonString = Encoding.UTF8.GetString(ms.ToArray());
ms.Close();
return jsonString;
}
/// <summary>
/// 對象反序列化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jsonString"></param>
/// <returns></returns>
public static T JsonToObject<T>(this string jsonString)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
T obj = (T)ser.ReadObject(ms);
return obj;
}
#endregion
#region net3.0 System.Web.Extensions.dll
/// <summary>
/// 使用net 3.0 json 反序列化，支持json字符串屬性不帶引號
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jsonString"></param>
/// <returns></returns>
public static T JsonToObj<T>(this string jsonString)
{
//引用 System.Web.Extensions.dll
System.Web.Script.Serialization.JavaScriptSerializer jss = new System.Web.Script.Serialization.JavaScriptSerializer();
return jss.Deserialize<T>(jsonString);
}
/// <summary>
/// 使用net 3.5 對象序列化成爲json 反序列化，支持json字符串屬性不帶引號
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jsonString"></param>
/// <returns></returns>
public static string ObjToJson<T>(this T t)
{
//引用 System.Web.Extensions.dll
System.Web.Script.Serialization.JavaScriptSerializer jss = new System.Web.Script.Serialization.JavaScriptSerializer();
return jss.Serialize(t);
}
#endregion
/// <summary>
/// JsonConvert.SerializeObject
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static string ToJson<T>(this T obj)
{
return JsonConvert.SerializeObject(obj);
}
/// <summary>
/// JsonConvert.DeserializeObject
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="content"></param>
/// <returns></returns>
public static T ToObject<T>(this string content)
{
return JsonConvert.DeserializeObject<T>(content);
}
}
5、Json 深刻
咱們都知道,在js中json的key 是可使用數字的，咱們學習了三種序列化方式，如何把一個json 的key 爲數字轉換成爲對象，咱們不少開發人員可能都會遇到過。
js 代碼以下
<script type="text/javascript">
var obj={1:123,2:456};
alert("obj[1]="+obj[1]);
var objText={"1":123,"2":456};
alert("objText[1]="+objText[1]);
alert("objText[1]="+objText["2"]);
</script>
在微軟，很早以前就想到了這一解決方案，可是在4.0升級的時候，升級出來一個bug ,DataContractJsonSerializer 再也不支持key 爲數字轉換，可是其餘的兩種方式都支持
咱們先來看下 JavaScriptSerializer 是如何序列化和反序列化key 爲數字的json 。
1.JavaScriptSerializer 類序列化和反序列化 key 爲數字：
Dictionary<int, string> dictionary1 = DataFactory.GetSkillAll();
Dictionary<string, string> dictionary2 = DataFactory.GetStrongAll();
try
{
string json = dictionary1.ObjToJson();
Dictionary<int, string> d = json.JsonToObj<Dictionary<int, string>>();
}
catch
{
}
try
{
string json = dictionary2.ObjToJson();
Dictionary<string, string> d = json.JsonToObj<Dictionary<string, string>>();
}
catch
{
}
咱們上述代碼分別爲兩個字典，字典值均爲數字，只是一個是字符串類型的，一個是整數類型的，整數類型的沒法序列化和反序列化，字符串類型的能夠序列化和反序列化。
看看序列化結果。
{"1":"abcdefg","2":"abcdefg123","3":"tvbcd","4":"您吃了嗎","5":"吃了嗎您呢","6":"tvbc 早上好","7":"vbbc 晚上好"}
也就是說，微軟在早期是隻支持字符串類型的數字key
2.JsonConvert類序列化和反序列化：
這個放心，不論key 是int 類型仍是string 類型，都支持的，咱們看下案列
Dictionary<int, string> dictionary1 = DataFactory.GetSkillAll();
Dictionary<string, string> dictionary2 = DataFactory.GetStrongAll();
string json1= dictionary1.ToJson();
string json2=dictionary2.ToJson();
Console.WriteLine(json1);
Console.WriteLine(json2);
完
源碼下載地址： 點擊下載