.Net 中关于序列化和反序列化Json的方法

.Net SDK中关于序列化和反序列化Json的方法

项目中遇到和服务端交互时需要传递数据包为json格式的包，所以在服务端和SDK中都需要对json进行解析和组合的操作， 并且对一些复杂结构的json格式的解析和序列化比较麻烦， 幸好，.Net提供一些方法的库可以帮助我们完成一些工作，下面介绍一下利用.Net中的Newtonsoft.Json.dll库对json进行序列化和反序列化操作。

Json操库的介绍：

.NET自身有System.Runtime.Serialization.dll与System.Web.Extensions.dll，使用这两个DLL可以把对象序列化和反序列化成Json数据。

也可以使用第三方的Newtonsoft.Json.dll来操作Json数据，使用它会更方便的操作Json数据，其功能也跟强一些。

但是：使用System.Web.Extensions.dll的限序列化， 一般不怎么使用，因为：要使用System.Web.Extensions.dll必须是在Web项目中，只有在Web项目中才能引用此DLL。

并且前两种方式在项目中也没怎么用过，所以主要介绍第三种方式，利用Newtonsoft.Json.dll来操作json.

首先要将该动态库加入到项目中，在.Net项目中直接添加引用即可。

1、 序列化

1.1 一般格式

要想得到一个最正常的以下格式的json结构：

{
"status": "create",
"subject": "envelope demo,sent recipients",
"message": "demo sign...",
"senderId": "0638bb2d-74c1-494b-ba50-e7caaf09ca77",
"projectKey": "10000006"
}

以下方法实现：

直接给json逐个字段构造

public class Json
{
JObject json { get; set; }
public string GetJson()
{
this.json = new JObject();
this.json["status"] = "create";
this.json["subject"] = "envelope demo";
this.json["message"] = "demo";
this.json["senderId"] = "0638bb2d";
this.json["projectKey"] = "10000006";
return this.json.ToString();
}
}

返回结果：

Json objjson = new Json();
string json = objjson.GetJson();

返回json为上面我们指定格式的字符串。

1.2 对象

将对象直接格式化为json字符串。

Eg：

public class Json

{

public string status { set; get; }

public string subject { set; get; }

public string message { set; get; }

public string senderId { set; get; }

public string projectKey { set; get; }

}

直接序列化：

Json objjson = new Json();

objjson.status = "create";………

string jsonData = JsonConvert.SerializeObject(objjson);

返回结果和上面一样的字符串， 前提是先给对象赋值， 如果不复制返回下面内容：

{"status":null,"subject":null,"message":null,"senderId":null,"projectKey":null}

注意：json key的名称和对象中的一样。 按照这样的逻辑，发序列化对象的名称要和json一样才能将其反序列化出来。

1.3 数组

使用List构造数组进行序列化,首先定义对象，构造格式；

如果想得到下列格式的json：

"documents":    [
{
"name": "demo.pdf",
"fileKey": "$08ac5875-345a-4339-a6a3-fca02a85ba92$180375027",
"templateRequired": "false",
"templateId": "",
"type": "pdf"
},
{
"name": "demo2.pdf",
"fileKey": "$08ac5875-325a-4339-a6a3-fca02a85ba92$180375046",
"templateRequired": "false",
"templateId": "",
"type": "pdf"
}
]

则使用对象序列化；

public class DocInfo
{
public string Name { set; get; }
public string FileKey { set; get; }
public string  TemplateRequired { set; get; }
public string TemplateId { set; get; }
public string Type { set; get; }
}
Void Main()
{
List<DocInfo> list = new List<DocInfo>();
DocInfo info = new DocInfo();
info.Name = "demo.pdf";
info.FileKey = "$08ac5875 - 325a - 4339 - a6a3 - fca02a85ba92$180375046";
info.TemplateRequired = "false";
info.Type = "pdf";
list.Add(info);

info.Name = "demo2.pdf";
info.FileKey = "$08ac5875-325a-4339-a6a3-fca02a85ba92$180375046";
list.Add(info);

string jsonStr = JsonConvert.SerializeObject(list);//将对象转换成json存储
this.Json["documents"] = JArray.Parse(strRecipients);
}

得到的便是以上我们定义的结构了；

1.4 嵌套格式

对于嵌套格式，通常都是由以上的三点的简单格式组成的，将其拆分合成后，组合到一起便可以了，或者定义对应结构的对象， 直接进行序列化即可完成。

2、 反序列化

2.1一般格式

解析如下格式：

string jsonText = "{\"zone\":\"海淀\",\"zone_en\":\"haidian\"}";
void main()
{
JObject jo = JObject.Parse(jsonData);
或者JObject jo = (JObject)JsonConvert.DeserializeObject(jsonData);

string zone = jo["zone"].ToString();
string zone_en = jo["zone_en"].ToString();
}

2.2对象

解析如下格式json:

string strJson =
{
"data":
{
"signedFileKey":"$f605cb35-2c4e-41f3-a16a-3eee41b39556$1638665701",
"signLogId": "02f1a5ff-d3e4-48df-9684-aed92081d6a7"
},
"errCode": 0,
"errShow": true,
"msg": ""
}
定义一个对象：
namespace JsonOper
{
public class JSON
{
public int ErrCode { get; set; }
public bool ErrShow { get; set; }
public string Msg { get; set; }
public DATA data { set; get; }
}

public class DATA
{
public string SignedFileKey { set; get; }
public string SignLogId { set; get; }
}
}

JSON jo = JsonConvert.DeserializeObject<JSON>(strJson);

得到的结果便是一个反序列化好了的对象。

注：定义发序列化对象时，要对象json格式定义， 比如有嵌套， 对象格式也要嵌套， 否则无法反序列化成功， 并且定义时，对象中的变量名称要和json中一直， 大小写没关系。

Eg：以上例子中

"errCode": 0,
"errShow": true,
"msg": ""

定义时可以定义为：

public class JSON
{
public int ErrCode { get; set; }
public bool ErrShow { get; set; }
public string Msg { get; set; }
}

因为反序列化是对属性的。 对象默认有一个小写字母开头的属性；总之这个无伤大雅。 一般首字母大写。

2.3数组

说来奇怪，项目中反序列化一个嵌套格式的json，定义了一个嵌套对象，但是竟然不成功， 一怒之下， 换了一种方法， 因为懒的去查什么原因了。

大体如下：

Json：
{
"data": {
"envelope": {
"status": "Sent",
"subject": "envelope demo,sent recipients",
"message": "demo sign...",
"redirectUrl": "http://xxxx.xxx.xxx/xxx",
"notifyUrl": "http://xxxx.xxx.xxx/xxx",
"senderId": "0638bb2d-74c1-494b-ba50-e7caaf09ca77",
"senderName": "Wesley",
"sentDateTime": "2017-08-17T06:55:48.6800000Z",
"document": {
"docUUID": "07ec608d-6840-4856-b599-783843efcdb6",
"signFileKey": "08ec608d-6840-4856-b599-783843efcdb6",
"name": "demo.pdf",
"templateRequired": "false",
"templateId": "",
"type": "Pdf"
},
"recipients": [{
"recipientId": "07ec608d-6840-4856-b599-783843efcdb6",
"flowId": "44ec608d-6840-4856-b599-783843efcbc6",
"currentHandlerFlag":"true",
"licenseType": "IDCard",
"licenseID": "362389xxxxxxxx8766",
"routingOrder": "1",
"type": "Signers",
"email": "123@123.com",
"phone": "12389978998",
"accountUniqueId": "23344555",
"departmentId": "dkdksjj",
"departmentName": "department A",
"autoSignFlag": "N",
"signType": "PatientSign",
"recipientType": "Personal",
"status": "Signed",
"predefineSign": {
"posType":"Free",
"key": "",
"posX": 0,
"posY": 0,
"posPage": "1"
}
},
{
"recipientId": "07ec608d-6840-4856-b599-783843efcdb6",
"flowId": "",
"currentHandlerFlag":"false",
"licenseType": "IDCard",
"licenseID": "362389xxxxxxxx8766",
"routingOrder": "2",
"type": "CC",
"email": "123@123.com",
"phone": "12389978998",
"accountUniqueId": "23344555",
"departmentId": "dkdksjj",
"departmentName": "department B",
"autoSignFlag": "N",
"signType": "PatientSign",
"recipientType": "Personal",
"status": "Sent",
"predefineSign": {
"posType":"Free",
"key": "",
"posX": 0,
"posY": 0,
"posPage": "1"
}
}]
},
"errCode": 0,
"errShow": true,
"msg": ""
}
}

以上结构中，有嵌套对象， 有嵌套数组， 数组中嵌套对象。

解析方法：

定义对象：

namespace xxxx
{
public class EnvelopInfoResult : Result
{
public EnvelopeDataResult EnvelopData { set; get; }

}
public class EnvelopeDataResult
{
public string Status { set; get; }
public String SubJect { set; get; }
public String Message { set; get; }
public String SenderId { set; get; }
public String SenderName { set; get; }
public string SentDateTime { set; get; }
public DocInfoResult Document { set; get; }
public List<RecipientsInfoPersonResult> PersonRecipientsInfos { set; get; }
public List<RecipientsInfoDepartResult> DepartRecipientsInfos { set; get; }
}
public class DocInfoResult
{
public string DocUUID { set; get; }
public string SignFileKey { set; get; }
public string Name { set; get; }
public string TemplateRequired { set; get; }
public string TemplateId { set; get; }
public string Type { set; get; }
}

public class PositionBeanResult
{
public string posType { set; get; }
public string PosPage { set; get; }
public string Key { get; set; }
public float PosX { get; set; }
public float PosY { get; set; }
public float Width { get; set; }
}

public class RecipientsReturn : Recipients
{
public string licenseType { set; get; }
public string licenseID { set; get; }
public string email { set; get; }
public string phone { set; get; }
public string accountUniqueId { set; get; }
public string recipientType { set; get; }
public string departmentId { set; get; }
public string autoSignFlag { set; get; }
public string signType { set; get; }
public string ReciepientId { set; get; }
public string FlowId { set; get; }
public string CurrentHanderFlag { set; get; }
public string DepartmentName { set; get; }
public string Status { set; get; }
}
}

将json解析到以上定义对象中：

JObject json = (JObject)JsonConvert.DeserializeObject(strJson);//转换为对象
EnvelopInfoResult  result = EnvelopInfoResult.ParseJson(json);
public static EnvelopInfoResult ParseJson(JObject json)
{
EnvelopInfoResult res = new EnvelopInfoResult();
EnvelopeDataResult data = new EnvelopeDataResult();
res.EnvelopData = data;

res.ErrCode = int.Parse(json["errCode"].ToString());
res.ErrShow = Convert.ToBoolean(json["errShow"].ToString());
res.Msg = json["msg"].ToString();
//Parse obj
//转换为对象
var obj = json["data"]["envelope"].ToObject<JObject>();
//获取对应字段值
res.EnvelopData.Status = obj.GetValue("status").ToString();            res.EnvelopData.SubJect = obj.GetValue("subject").ToString();
res.EnvelopData.Message = obj.GetValue("message").ToString();
res.EnvelopData.SenderId = obj.GetValue("senderId").ToString();
res.EnvelopData.SenderName = obj.GetValue("senderName").ToString();
res.EnvelopData.SentDateTime = obj.GetValue("sentDateTime").ToString();
//将document对象直接转换为定义的对象
res.EnvelopData.Document = obj.GetValue("document").ToObject<DocInfoResult>();
// recipients对应的数组部分是一个对象， 获取json将其转换成JArray数组，然后遍历数组获取每个字段对应的值。
string strListJson = obj.GetValue("recipients").ToString();
JArray jar = JArray.Parse(strListJson);

foreach (var nobj in jar)
{
RecipientsReturn rec = nobj.ToObject<RecipientsReturn>();
if ("Personal" == rec.recipientType)
{
res.EnvelopData.PersonRecipientsInfos = new List<RecipientsInfoPersonResult>();
RecipientsInfoPersonResult Recp = new RecipientsInfoPersonResult();

Recp.ReciepientId = rec.ReciepientId;
Recp.FlowId = rec.FlowId;
Recp.CurrentHanderFlag = Convert.ToBoolean(rec.CurrentHanderFlag);
Recp.licenseType = GetType<LicenseType>(rec.licenseType);                      Recp.LicenseId = rec.licenseID;
Recp.RoutingOrder = rec.routingOrder;
Recp.Type = GetType<SendType>(rec.type);
Recp.Email = rec.email;
Recp.Phone = rec.phone;
Recp.AccountUniqueId = rec.accountUniqueId;
Recp.SignType = GetType<SignType>(rec.signType);
Recp.status = GetType<RecipientStatus>(rec.Status);
Recp.PredefineSign = SetPos(rec.predefineSign);
res.EnvelopData.PersonRecipientsInfos.Add(Recp);
}
else
{
res.EnvelopData.DepartRecipientsInfos = new List<RecipientsInfoDepartResult>();
RecipientsInfoDepartResult Recd = new RecipientsInfoDepartResult();
Recd.RecipientId = rec.ReciepientId;
Recd.FlowId = rec.FlowId;
Recd.CurrentHandlerFlag = Convert.ToBoolean(rec.CurrentHanderFlag);
Recd.RoutingOrder = rec.routingOrder;
Recd.AccountUniqueId = rec.accountUniqueId;
Recd.DepartmentId = rec.departmentId;
Recd.AutoSignFlag = Convert.ToBoolean(rec.autoSignFlag);
Recd.status = GetType<RecipientStatus>(rec.Status);
Recd.PredefineSign = SetPos(rec.predefineSign);
res.EnvelopData.DepartRecipientsInfos.Add(Recd);
}

}
return res;
}

好了，打完收工。