准备好饮料，咱们一块儿来玩玩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);
完
源码下载地址： 点击下载