使用DataContractJsonSerializer类将类型实例序列化为JSON字符串和反序列化为实例对象
浅谈C#中的序列化与反序列化
浅谈C#中的序列化与反序列化今天我利⽤这篇⽂章给⼤家讲解⼀下C#中的序列化与反序列化。
这两个概念我们再开发中经常⽤到,但是我们绝⼤部分只⽤到了其中的⼀部分,剩下的部分很多开发⼈员并不清楚,甚⾄可以说是不知道。
因此我希望通过这篇⽂章能让⼤家对序列化和反序列化的知识有更进⼀步的掌握。
废话不多说,开始进⼊正题。
⼀、什么是序列化/反序列化在所有的开发语⾔中都存在序列化和反序列化这个概念,所谓的序列化就是把⼀个对象信息转化为⼀个可以持久存储的数据形式,经过转化后就可以⽅便的保存和传输了,因此序列化主要⽤于平台之间的通讯。
由于序列化我们可以反推出所谓的反序列化就是将持久存储的数据还原为对象。
⼆、C#中的序列化/反序列化在C#中我们经常会对Json和Xml进⾏序列化和反序列化,但是还存在⼀种序列化/反序列化,那就是将对象序列化为⼆进制⽂件,将⼆进制⽂件反序列化为对象。
下⾯我会对这三种序列化和反序列化进⾏解释。
1、JsonJson的英⽂全称是JavaScript Object Notation,是⼀种轻量级的数据交换格式,完全独⽴于语⾔的⽂本格式,易于⼈阅读和编写,同时也易于机器解析和⽣成。
Json是⽬前互联⽹中主流的交换格式,同时也是很多开发语⾔配置⽂件的主流格式。
在.Net中存在两个类对Json进⾏处理,分别是DataContractJsonSerializer和JavaScriptSerializer,这两种类的功能基本⼀致。
DataContractJsonSerializer位于命名空间 System.Runtime.Serialization.Json下,他的特点是必须⽤DatContract以及DataMember属性标记成员。
JavaScriptSerializer位于命名空间System.Web.Script.Serialization下,通过名字和他所在的命名空间我们可以得知他主要⽤在⽹络通信中,他可以序列化任何类型的对象。
C#对象与JSON字符串互相转换的三种方式
C#对象与JSON字符串互相转换的三种⽅式C# 对象与JSON字符串互相转换的三种⽅式JSON(JavaScript Object Notation, JS 对象标记) 是⼀种轻量级的数据交换格式。
关于内存对象和JSON字符串的相互转换,在实际项⽬中应⽐较⼴泛,经过⼀番搜索,找到如下三种⽅法来解决此问题分别是使⽤ Newtonsoft.Json.dll、DataContractJsonSerializer、 JavaScriptSerializer。
⽅法⼀: Newtonsoft.Json.dllNewtonsoft.Json.dll在.net2.0之后的版本可以⽀持我的版本.net framework4.0添加Newtonsoft.json的引⽤对象与json字符串转换类设计1class JsonNewtonsoft2 {3///<summary>4///把对象转换为JSON字符串5///</summary>6///<param name="o">对象</param>7///<returns>JSON字符串</returns>8public static string ToJSON(this object o)9 {10if (o == null)11 {12return null;13 }14return JsonConvert.SerializeObject(o);15 }16///<summary>17///把Json⽂本转为实体18///</summary>19///<typeparam name="T"></typeparam>20///<param name="input"></param>21///<returns></returns>22public static T FromJSON<T>(this string input)23 {24try25 {26return JsonConvert.DeserializeObject<T>(input);27 }28catch (Exception ex)29 {30return default(T);31 }32 }33 }⽅法⼆:DataContractJsonSerializer使⽤这种需要引⽤ System.Runtime.Serialization.dll类设计1class JsonDataContractJsonSerializer2 {3///<summary>4///内存对象转换为json字符串5///</summary>6///<param name="obj"></param>7///<returns></returns>8public static string ObjectToJson(object obj)9 {10 DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());11 MemoryStream stream = new MemoryStream();12 serializer.WriteObject(stream, obj);13byte[] dataBytes = new byte[stream.Length];14 stream.Position = 0;15 stream.Read(dataBytes, 0, (int)stream.Length);16return Encoding.UTF8.GetString(dataBytes);17 }18///<summary>19/// Json字符串转内存对象20///</summary>21///<param name="jsonString"></param>22///<param name="obj"></param>23///<returns></returns>24public static object JsonToObject(string jsonString, object obj)25 {26 DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());27 MemoryStream mStream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));28return serializer.ReadObject(mStream);29 }30 }⽅法三:JavaScriptSerializer需要引⽤:System.Web.Extensions.dll类设计1public static class JsonJavaScriptSerializer2 {3///<summary>4///内存对象转换为json字符串5///</summary>6///<param name="obj"></param>7///<returns></returns>8public static string ToJSON(object obj)9 {10 StringBuilder sb = new StringBuilder();11 JavaScriptSerializer json = new JavaScriptSerializer();12 json.Serialize(obj, sb);13return sb.ToString();14 }15///<summary>16/// Json字符串转内存对象17///</summary>18///<param name="jsonString"></param>19///<param name="obj"></param>20///<returns></returns>21public static T FromJSON<T>(string jsonString)22 {23 JavaScriptSerializer json = new JavaScriptSerializer();24return json.Deserialize<T>(jsonString);25 }2627 }程序测试:新建⼀个测试对象类Student.cs1public enum Sex2 {3男=0,4⼥=15 }6 [Serializable()]7class Student8 {9private string _name;1011public string Name12 {13get { return _name; }14set { _name = value; }15 }1617private int _age;1819public int Age20 {21get { return _age; }22set { _age = value; }23 }2425private Sex _sex = Sex.男;2627public Sex Sex28 {29get { return _sex; }30set { _sex = value; }31 }32public Student()33 { }34public Student(string name,int age,Sex sex)35 {36this._name = name;37this._age = age;38this._sex = sex;39 }40 }测试程序1static void Main(string[] args)2 {3 Student st = new Student("笨男孩",22,Sex.男);45 Console.WriteLine("============⽅法⼀============================================"); 6//⽅法⼀78 Console.WriteLine("⽅法⼀对象转Json字符串");9string jsonStr = JsonNewtonsoft.ToJSON(st);10 Console.WriteLine(jsonStr);11 Console.WriteLine("⽅法⼀Json字符串转对象");12 Student stobj = (Student)JsonNewtonsoft.FromJSON<Student>(jsonStr);13 Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}",,stobj.Age,stobj.Sex);141516 Console.WriteLine("============⽅法⼆============================================"); 17//⽅法⼆18 Console.WriteLine("⽅法⼆对象转Json字符串");19string jsonStr2 = JsonDataContractJsonSerializer.ToJSON(st);20 Console.WriteLine(jsonStr2);21 Console.WriteLine("⽅法⼆Json字符串转对象");22 Student stobj2 = (Student)JsonDataContractJsonSerializer.FromJSON(jsonStr2, st);23 Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}", , stobj2.Age, stobj2.Sex);242526 Console.WriteLine("============⽅法三============================================"); 27//⽅法⼆28 Console.WriteLine("⽅法三对象转Json字符串");29string jsonStr3 = JsonJavaScriptSerializer.ToJSON(st);30 Console.WriteLine(jsonStr3);31 Console.WriteLine("⽅法三Json字符串转对象");32 Student stobj3 = (Student)JsonJavaScriptSerializer.FromJSON<Student>(jsonStr3);33 Console.WriteLine("姓名:{0} 年龄:{1} 性别:{2}", , stobj3.Age, stobj3.Sex);3435 Console.ReadKey();36 }程序运⾏结果:运⾏结果:功能对⽐:性能对⽐:参考:。
C#的Json数据格式转换方法
C#的Json数据格式转换方法///<summary>///FileName: JSONHelper.cs///CLRVersion: 2.0.50727.3623///Author: Mikel///Corporation:///Description:JSON格式数据转换助手类/// 1.将List<T>类型的数据转换为JSON格式/// 2.将T类型对象转换为JSON格式对象/// 3.将JSON格式对象转换为T类型对象///DateTime: 2011-09-13 14:11:34///</summary>public static class JSONHelper{///<summary>///转换对象为JSON格式数据///</summary>///<typeparam name="T">类</typeparam>///<param name="obj">对象</param>///<returns>字符格式的JSON数据</returns>public static string GetJSON<T>(object obj){string result = String.Empty;try{System.Runtime.Serialization.Json.DataContractJsonSerializer serializer =newSystem.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) {serializer.WriteObject(ms, obj);result = System.Text.Encoding.UTF8.GetString(ms.ToArray()); }}catch (Exception ex){throw ex;}return result;}///<summary>///转换List<T>的数据为JSON格式///</summary>///<typeparam name="T">类</typeparam>///<param name="vals">列表值</param>///<returns>JSON格式数据</returns>public static string JSON<T>(List<T> vals){System.Text.StringBuilder st = new System.Text.StringBuilder();try{System.Runtime.Serialization.Json.DataContractJsonSerializer s = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));foreach (T city in vals){using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) {s.WriteObject(ms, city);st.Append(System.Text.Encoding.UTF8.GetString(ms.ToArray())); }}}catch (Exception ex){throw ex;}return st.ToString();}///<summary>///JSON格式字符转换为T类型的对象///</summary>///<typeparam name="T"></typeparam>///<param name="jsonStr"></param>///<returns></returns>public static T ParseFormByJson<T>(string jsonStr){T obj = Activator.CreateInstance<T>();using (System.IO.MemoryStream ms =newSystem.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonStr))){System.Runtime.Serialization.Json.DataContractJsonSerializerserializer =newSystem.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));return (T)serializer.ReadObject(ms);}}}namespace System.Web.Mvc {using System;using System.Text;using System.Web;using System.Web.Script.Serialization;[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDema nd, Level = AspNetHostingPermissionLevel.Minimal)][AspNetHostingPermission(System.Security.Permissions.SecurityAction.Inherita nceDemand, Level = AspNetHostingPermissionLevel.Minimal)]public class JsonResult : ActionResult {public Encoding ContentEncoding {get;set;}public string ContentType {get;set;}public object Data {get;set;}public override void ExecuteResult(ControllerContext context) { if (context == null) {throw new ArgumentNullException("context");}HttpResponseBase response = context.HttpContext.Response;if (!String.IsNullOrEmpty(ContentType)) {response.ContentType = ContentType;}else {response.ContentType = "application/json";}if (ContentEncoding != null) {response.ContentEncoding = ContentEncoding;}if (Data != null) {#pragma warning disable 0618JavaScript.Serializer serializer = new JavaScript.Serializer(); response.Write(serializer.Serialize(Data));#pragma warning restore 0618}}}}注意:一定要先引用c:\Program Files\ReferenceAssemblies\Microsoft\Framework\v3.5\System.Web.Extensions.dll 才能使用JavaScriptSerializer serializer = new JavaScriptSerializer(); 切记!。
datacontractjsonserializer 用法
datacontractjsonserializer 用法一、概述DataContractJsonSerializer 是 .NET Framework 提供的一种用于序列化对象到 JSON 格式的工具。
它可以将对象转换为 JSON 字符串,也可以将 JSON 字符串反序列化为对象。
本文档将详细介绍DataContractJsonSerializer 的用法。
二、安装要使用 DataContractJsonSerializer,需要将其添加到项目引用中。
可以通过 NuGet 包管理器或手动下载并添加到项目文件。
三、序列化对象为 JSON要使用 DataContractJsonSerializer 将对象序列化为 JSON,需要按照以下步骤操作:1. 创建一个包含要序列化的对象的类,该类必须被标记为[DataContract] 和 [JsonObjectNameAttribute]。
2. 实例化 DataContractJsonSerializer 对象,并提供要序列化的对象和输出文件的路径。
3. 使用 WriteObject 方法将序列化后的 JSON 数据写入文件或流中。
以下是一个示例代码:```csharp[DataContract]public class Person{[DataMember]public string Name { get; set; }[DataMember]public int Age { get; set; }}// 创建序列化器对象并序列化对象到文件DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Person));FileStream stream = new FileStream("person.json", FileMode.Create);serializer.WriteObject(stream, person);stream.Close();```在上述代码中,我们首先定义了一个 Person 类,并将其标记为[DataContract] 和 [JsonObjectNameAttribute]。
Json序列化和反序列化方法解析
Json序列化和反序列化⽅法解析复制代码代码如下:/// <summary>/// Json序列化,⽤于发送到客户端/// </summary>public static string ToJsJson(this object item){DataContractJsonSerializer serializer = new DataContractJsonSerializer(item.GetType()); using (MemoryStream ms = new MemoryStream()){serializer.WriteObject(ms, item);StringBuilder sb = new StringBuilder();sb.Append(Encoding.UTF8.GetString(ms.ToArray()));return sb.ToString();}}/// <summary>/// Json反序列化,⽤于接收客户端Json后⽣成对应的对象/// </summary>public static T FromJsonTo<T>(this string jsonString){DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));T jsonObject = (T)ser.ReadObject(ms);ms.Close();return jsonObject;}实体类复制代码代码如下:[DataContract]public class TestObj{[DataMember]public string make { get; set; }[DataMember]public string model { get; set; }[DataMember]public int year { get; set; }[DataMember]public string color { get; set; }}------------------javascript获取Json--------------------javascript调⽤测试代码复制代码代码如下:$('#getJson').click(function() {$.ajax({url: "getJsonHandler.ashx",type: 'GET',data: {},dataType: 'json',timeout: 1000,error: function(XMLHttpRequest, textStatus, errorThrown) { alert(textStatus) },success: function(result) {alert(result.make);alert(result.model);alert(result.year);alert(result.color);}});});C#后台⽣成代码复制代码代码如下:public class getJsonHandler: IHttpHandler{public void ProcessRequest(HttpContext context){TestObj obj = new TestObj();obj.make = "Make is Value";obj.model = "Model is Value";obj.year = 999;obj.color = "Color is Value";context.Response.Write(obj.ToJsJson());}public bool IsReusable{get{return false;}}}//返回值为 {"color":"Color is Value","make":"Make is Value","model":"Model is Value","year":999}-----------------C#由Json⽣成对象-----------------------javascript调⽤测试代码复制代码代码如下:$('#postJson').click(function() {var m_obj = { make: "Dodge", model: "Coronet R/T", year: 1968, color: "yellow" };var jsonStr = JSON.stringify(m_obj); //⽤Json2.js⽣成Json字符串$.ajax({url: "postJsonHandler.ashx",type: 'POST',data: { postjson: jsonStr },dataType: 'json',timeout: 1000,error: function(XMLHttpRequest, textStatus, errorThrown) { alert(textStatus) },success: function(result) {alert(result.success);}});});C#后台⽣成代码复制代码代码如下:public class postJsonHandler: IHttpHandler{public void ProcessRequest(HttpContext context){string jsonStr = context.Request["postjson"];TestObj obj = jsonStr.FromJsonTo<TestObj>();if (string.IsNullOrEmpty(obj.make) || string.IsNullOrEmpty(obj.model) || string.IsNullOrEmpty(obj.color)|| obj.year < 0){context.Response.Write("{success:false}");}else{context.Response.Write("{success:true}");}public bool IsReusable{get{return false;}}}使⽤Json时需要注意,服务器端拼凑⽣成Json字符串时,⼀定要注意把字符串⽤\"\"包裹,不然客户端接收时肯定会报错,根据Json 字符串⽣成对象,是根据对应的名称赋值,多于或少于都不会报错.。
JsonXML序列化和反序列化
2)使用JavaScriptSerializer类 使用JavaScriptSerializer方式需要引入的命名空间,这个在程序集System.Web.Extensions.dll.中;
3)使用DataContractJsonSerializer类 使用DataContractJsonSerializer方式需要引入的命名空间,在System.Runtime.Serialization.dll.中;
网络错误421请刷新页面重试持续报错请尝试更换浏览器或网络环境
JsonXML序 列 化 Байду номын сангаас 反 序 列 化
1.json序列化和反序列化 序列化是将对象状态转换为可保持或传输的格式的过程; 反序列化,它将流转换为对象; 1) 推荐使用类库,需要引入的命名空间; 序列化:JsonConvert.SerializeObject 反序列化:JsonConvert.DeserializeObject
反序列化:
java jsonserializer用法
java jsonserializer用法一、概述JSONSerializer是Java中用于将Java对象序列化为JSON格式的工具。
它可以将Java对象转换为易于阅读和传输的JSON字符串,同时也可以将JSON字符串反序列化为Java对象。
在本篇文档中,我们将介绍JSONSerializer的基本用法、类和接口、常用方法以及示例代码。
二、JSONSerializer类和接口JSONSerializer类是Java中用于序列化Java对象的工具类,它继承自JsonSerializer类。
在JSONSerializer类中,定义了一些常用的方法,如writeObject、writeArray等,用于将Java对象转换为JSON格式。
同时,JSONSerializer还提供了对JSON格式的字符串进行解析的方法,如readObject、readArray等,用于将JSON字符串反序列化为Java对象。
三、常用方法1. writeObject(Object object):将Java对象序列化为JSON格式的字符串。
2. writeArray(Object array):将Java数组序列化为JSON格式的字符串。
3. readObject(String json):将JSON格式的字符串反序列化为Java对象。
4. readArray(String json):将JSON格式的字符串反序列化为Java数组。
四、示例代码以下是一个简单的示例代码,展示如何使用JSONSerializer将Java对象序列化为JSON格式的字符串,并反序列化为Java对象:```javaimport com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.SerializationFeature;import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator;import java.io.IOException;import java.util.HashMap;import java.util.Map;public class JsonSerializerExample {public static void main(String[] args) {// 创建一个Java对象Map<String, Object> map = new HashMap<>();map.put("name", "John");map.put("age", 30);map.put("gender", "male");Map<String, String> phoneNumbers = new HashMap<>();phoneNumbers.put("home", "123456789");phoneNumbers.put("work", "987654321");map.put("phoneNumbers", phoneNumbers);Person person = new Person(map);// 将Java对象序列化为JSON格式的字符串ObjectMapper objectMapper = new ObjectMapper();objectMapper.enable(SerializationFeature.INDENT_OUTPUT);try {String jsonString =objectMapper.writeValueAsString(person);System.out.println(jsonString); // 输出: {"name":"John","age":30,"gender":"male","phoneNumbers":{"home":"12345678 9","work":"987654321"}}} catch (JsonProcessingException e) {e.printStackTrace();}// 将JSON格式的字符串反序列化为Java对象try {Person personFromJson =objectMapper.readValue(jsonString, Person.class);System.out.println(personFromJson); // 输出: John, 30, Male, [Home: 123456789, Work: 987654321]} catch (IOException e) {e.printStackTrace();}}}```以上示例代码中,我们首先创建了一个Person对象,并使用ObjectMapper 将其序列化为JSON格式的字符串。
jsonserializer 编码
JsonSerializer是一种编码工具,用于将数据转换为JSON格式。
它提供了许多功能和选项,使开发人员可以轻松地将对象序列化为JSON,或将JSON反序列化为对象。
在本文中,我们将探讨JsonSerializer编码的相关主题和内容,并深入了解其原理、功能和用法,以及一些常见的使用案例和最佳实践。
通过本文的阅读,读者将获得对JsonSerializer编码的全面了解,以及如何在实际项目中有效地应用它。
一、JsonSerializer编码的原理和基本概念1.1 JsonSerializer的定义和作用JsonSerializer是一种用于将数据序列化为JSON格式的编码工具。
它可以将各种类型的数据转换为JSON数据,包括简单的数据类型(如整数、字符串等)和复杂的数据结构(如对象、数组等)。
1.2 JsonSerializer的原理和工作流程在使用JsonSerializer时,开发人员可以通过调用其API方法,将数据传入编码器中。
编码器会根据数据的类型和结构,将其转换为对应的JSON数据。
这个过程涉及到数据的遍历和转换,以及JSON数据的格式化和组装,最终得到符合JSON规范的数据字符串。
1.3 JsonSerializer的基本概念和术语在使用JsonSerializer时,开发人员需要了解一些基本的概念和术语,如序列化、反序列化、属性映射、数据转换等。
这些概念和术语对于理解和应用JsonSerializer至关重要,帮助开发人员更加高效地使用这个工具。
二、JsonSerializer编码的功能和选项2.1 JsonSerializer的常用功能和功能点JsonSerializer提供了许多常用的功能和选项,如数据的格式化、空值的处理、属性的映射、循环引用的处理等。
这些功能和选项可以帮助开发人员更加灵活地控制编码过程,以满足不同的需求和场景。
2.2 JsonSerializer的特殊功能和高级用法除了常用的功能和选项外,JsonSerializer还提供了一些特殊的功能和高级的用法,如自定义序列化器、自定义转换器、自定义属性映射策略等。
jsonserializer 数组
在Python中,JSON序列化是将Python对象转换为JSON格式的过程。
而Python自带的json库提供了`json.dumps()`函数,可以将Python对象序列化为JSON字符串。
但是,如果你需要自定义JSON序列化方式,可以使用`json.JSONEncoder`类,并重写其中的`default()`方法。
下面是一个示例,演示如何将Python数组(list)序列化为JSON 格式:```pythonimport jsonclass MyEncoder(json.JSONEncoder):def default(self, obj):if isinstance(obj, list):return ','.join(str(i) for i in obj)return json.JSONEncoder.default(self, obj)data = ['apple', 'banana', 'cherry']json_str = json.dumps(data, cls=MyEncoder)print(json_str) # 输出:["apple","banana","cherry"]```在这个示例中,我们创建了一个自定义的JSON编码器`MyEncoder`,重写了`default()`方法,将数组(list)转换成字符串。
在`default()`方法中,我们使用`isinstance()`函数判断对象是否是数组类型,如果是,就使用`join()`函数将数组中的元素转换成字符串并拼接在一起。
最后,我们使用`json.dumps()`函数将数据序列化为JSON字符串,并将自定义编码器作为参数传入。
datacontractjsonserializer 用法 -回复
datacontractjsonserializer 用法-回复DataContractJsonSerializer 是 .NET Framework 中的一个类,用于将对象序列化和反序列化为JSON 格式的数据。
它是用于处理数据交换的Microsoft 的开放式标准,适用于跨平台、跨语言的数据交互。
在本文中,我们将探讨DataContractJsonSerializer 的用法,并逐步回答一些常见问题。
1. DataContractJsonSerializer 是什么?DataContractJsonSerializer 是 .NET Framework 中的一个类,用于将对象序列化和反序列化为JSON 数据。
JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,易于阅读和编写,也易于机器解析和生成。
通过使用DataContractJsonSerializer,可以在不同的平台和语言之间轻松地传输和交换数据。
2. 如何使用DataContractJsonSerializer 进行序列化?使用DataContractJsonSerializer 进行序列化需要以下几个步骤:a. 创建一个用于序列化的对象。
b. 使用DataContract 属性将类和成员标记为序列化数据的一部分。
c. 创建一个MemoryStream 对象来保存序列化后的数据。
d. 使用DataContractJsonSerializer 的WriteObject 方法将对象序列化到MemoryStream 中。
e. 使用MemoryStream 的ToArray 方法,将序列化后的数据转换为字节数组。
下面是一个示例代码,演示了如何使用DataContractJsonSerializer 进行序列化:using System;using System.IO;using System.Runtime.Serialization;using System.Runtime.Serialization.Json;[DataContract]public class Person{[DataMember]public string Name { get; set; }[DataMember]public int Age { get; set; }}class Program{static void Main(string[] args){Person person = new Person(){Name = "John",Age = 30};DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Person));MemoryStream stream = new MemoryStream();serializer.WriteObject(stream, person);byte[] jsonBytes = stream.ToArray();Console.WriteLine(Encoding.UTF8.GetString(jsonBytes));stream.Close();Console.ReadLine();}}在这个示例中,我们创建了一个名为Person 的类,并使用DataMember 属性标记它的Name 和Age 属性。
C#使用DataContractJsonSerializer实现Json格式的序列化和反序列化
C#使⽤DataContractJsonSerializer实现Json格式的序列化和反序列化public Student(string name, int age){_Name = name;_Age = age;}/// <summary>/// 姓名/// </summary>[System.Runtime.Serialization.DataMember]public string Name{set {_Name = value;}get { return _Name; }}/// <summary>/// 年龄/// </summary>[System.Runtime.Serialization.DataMember]public int Age{set { _Age = value; }get { return _Age; }}}注意:必须使⽤DataContractAttribute对类进⾏标记,使⽤DataMemberAttribute类成员进⾏标记,否则该类⽆法被序列化。
对象转为JSON字符串程序代码Student stu = new Student("⼩李", 30);System.Runtime.Serialization.Json.DataContractJsonSerializer json = newSystem.Runtime.Serialization.Json.DataContractJsonSerializer(stu.GetType());using (MemoryStream stream = new MemoryStream()){json.WriteObject(stream, stu);Response.Write(System.Text.Encoding.UTF8.GetString(stream.ToArray()));}JSON字符串转为对象程序代码System.Runtime.Serialization.Json.DataContractJsonSerializer json = newSystem.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(Student));using (MemoryStream stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes("{\"Age\":20,\"Name\":\"张三\"} "))){Student stu = (Student)json.ReadObject(stream);Response.Write(string.Format("name:{0},age:{1}", , stu.Age));}注:.NET Framework 3.5下才可⽤DataContractJsonSerializer!。
序列化和反序列化的几种方式(DataContractSerializer)(二)
序列化和反序列化的⼏种⽅式(DataContractSerializer)(⼆)DataContractSerializer 类使⽤提供的数据协定,将类型实例序列化和反序列化为 XML 流或⽂档。
⽆法继承此类。
命名空间: System.Runtime.Serialization程序集: System.Runtime.Serialization(在 System.Runtime.Serialization.dll 中)备注使⽤ DataContractSerializer 类可以将类型实例序列化和反序列化为 XML 流或⽂档。
通过将 DataContractAttribute 特性应⽤于类,⽽将DataMemberAttribute 特性应⽤于类成员,可以指定要序列化的属性和字段。
从字⾯意思来理解就是:数据契约序列化,本⽂主要是讲解⽤DataContractSerializer 序列化和反序列化,关于它在WCF中的应⽤⼤家可以参考《WCF全⾯解析上册蒋⾦楠著》第五章序列化,⾥⾯有专门的介绍。
DataContractAttribute与DataMenmberAttribute1#region程序集 System.Runtime.Serialization.dll, v4.0.0.02// C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Runtime.Serialization.dll3#endregion45using System;67namespace System.Runtime.Serialization8 {9// 摘要:10// 指定该类型要定义或实现⼀个数据协定,并可由序列化程序(如 System.Runtime.Serialization.DataContractSerializer)进⾏序列化。
c#使用JSON序列化DataContractJsonSerializer
c#使⽤JSON序列化DataContractJsonSerializer c# 可以使⽤DataContractJsonSerializer 进⾏JSON的序例化;需要引⽤命名空间 using System.Runtime.Serialization.Json;当不需要序例化时,只需要在相应的字段上加 [NonSerialized]例如:[NonSerialized]private double m_UpValue;下⾯给出序例化的过程:/// <summary>/// Serialize T to string/// </summary>/// <param name="item"></param>/// <returns></returns>public static string Serialize<T>(T item){if (item == null) return string.Empty;var serializer = new DataContractJsonSerializer(item.GetType());using (var ms = new MemoryStream()){serializer.WriteObject(ms, item);var sb = new StringBuilder();sb.Append(Encoding.UTF8.GetString(ms.ToArray()));return sb.ToString();}}/// <summary>/// Deserialize string back to T/// </summary>/// <param name="jsonString"></param>/// <returns></returns>public static T Deserialize<T>(string jsonString){if (string.IsNullOrEmpty(jsonString)) return default(T);var ser = new DataContractJsonSerializer(typeof(T));using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString))){T jsonObject = (T)ser.ReadObject(ms);return jsonObject;}}。
Json序列化以及反序列化的三种方式(二)
Json序列化以及反序列化的三种⽅式(⼆)1.什么是JSON?Json【javascript对象表⽰⽅法】,它是⼀个轻量级的数据交换格式,我们可以很简单的来读取和写它,并且它很容易被计算机转化和⽣成,它是完全独⽴于语⾔的2.Json⽀持下⾯两种数据结构键值对的集合--各种不同的编程语⾔,都⽀持这种数据结构;有序的列表类型值的集合--这其中包含数组,集合,⽮量,或者序列,等等。
3.Json有下⾯⼏种表现形式1对象⼀个没有顺序的“键/值”,⼀个对象以花括号“{”开始,并以花括号"}"结束,在每⼀个“键”的后⾯,有⼀个冒号,并且使⽤逗号来分隔多个键值对var user = "{'name':'Manas','gender':'Male','birthday':'1987-8-8'}";2.数组设置值的顺序,⼀个数组以中括号"["开始,并以中括号"]"结束,并且所有的值使⽤逗号分隔var user_Array = "[{'user': {'name':'Manas','gender':'Male','birthday':'1987-8-8'}}, {'user':{'name':'Mohapatra','Male':'Female','birthday':'1987-7-7'}}]";3.字符串任意数量的Unicode字符,使⽤引号做标记,并使⽤反斜杠来分隔。
var user_String = "{\"ID\":1,\"Name\":\"Manas\",\"Address\":\"India\"}";序列化和反序列化有三种⽅式:1. 使⽤JavaScriptSerializer类2. 使⽤DataContractJsonSerializer类3. 使⽤类库我们先来看看使⽤ DataContractJsonSerializer的情况的引⽤//----------------------------------------------------------------------------------------------//使⽤DataContractJsonSerializer⽅式需要引⼊的命名空间,在System.Runtime.Serialization.dll.中using System.Runtime.Serialization.Json;//---再看看使⽤JavaScriptJsonSerializer的情况的引⽤//-----------------------------------------------------------------------------------------//使⽤JavaScriptSerializer⽅式需要引⼊的命名空间,这个在程序集System.Web.Extensions.dll.中using System.Web.Script.Serialization;//-------------------------------------------------------------------------最后看看使⽤的情况,引⼊类库://使⽤类库需要引⼊的命名空间//-----------------------------------------------------------------------------using Newtonsoft.Json;//-------------------------------------------------------------------------最后实战控制台代码:using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Runtime.Serialization.Json;using System.IO;using System.Web.Script.Serialization;using Newtonsoft.Json;namespace Test_Control{public class Students{public int ID { get; set; }public string Name { get; set; }public int Age { get; set; }public string Sex { get; set; }}class Test2{static void Main(string[] args){var user = "{'name':'Manas','gender':'Male','birthday':'1987-8-8'}";var user_Array = "[{'user': {'name':'Manas','gender':'Male','birthday':'1987-8-8'}}, {'user':{'name':'Mohapatra','Male':'Female','birthday':'1987-7-7'}}]";var user_String = "{\"ID\":1,\"Name\":\"Manas\",\"Address\":\"India\"}";#region 1.DataContractJsonSerializer⽅式序列化和反序列化Students stu = new Students(){ID = 1,Name = "曹操",Sex = "男",Age = 1000};//序列化DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(Students));MemoryStream msObj = new MemoryStream();//将序列化之后的Json格式数据写⼊流中js.WriteObject(msObj, stu);msObj.Position = 0;//从0这个位置开始读取流中的数据StreamReader sr = new StreamReader(msObj, Encoding.UTF8);string json = sr.ReadToEnd();sr.Close();msObj.Close();Console.WriteLine(json);//反序列化string toDes = json;//string to = "{\"ID\":\"1\",\"Name\":\"曹操\",\"Sex\":\"男\",\"Age\":\"1230\"}";using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(toDes))){//js 反序列化为对象JavaScriptSerializer jss = new JavaScriptSerializer();var str_Object = jss.Deserialize<Students>(toDes);DataContractJsonSerializer deseralizer = new DataContractJsonSerializer(typeof(Students));Students model = (Students)deseralizer.ReadObject(ms);//反序列化ReadObjectConsole.WriteLine("ID=" + model.ID);Console.WriteLine("Name=" + );Console.WriteLine("Age=" + model.Age);Console.WriteLine("Sex=" + model.Sex);}Console.ReadKey();答案{"Age":1000,"ID":1,"Name":"曹操","Sex":"男"}ID=1Name=曹操Age=1000Sex=男#endregion#region 2.JavaScriptSerializer⽅式实现序列化和反序列化Students stu = new Students(){ID = 1,Name = "关⽻",Age = 2000,Sex = "男"};JavaScriptSerializer js = new JavaScriptSerializer();string jsonData = js.Serialize(stu);//序列化Console.WriteLine(jsonData);//反序列化⽅式⼀:string desJson = jsonData;Students model = js.Deserialize<Students>(desJson);////反序列化string message = string.Format("ID={0},Name={1},Age={2},Sex={3}", model.ID, , model.Age, model.Sex);Console.WriteLine(message);//反序列化⽅式2dynamic modelDy = js.Deserialize<dynamic>(desJson); //反序列化string messageDy = string.Format("动态的反序列化,ID={0},Name={1},Age={2},Sex={3}",modelDy["ID"], modelDy["Name"], modelDy["Age"], modelDy["Sex"]);//这⾥要使⽤索引取值,不能使⽤对象.属性Console.WriteLine(messageDy);Console.ReadKey();答案{"ID":1,"Name":"关⽻","Age":2000,"Sex":"男"}ID=1,Name=关⽻,Age=2000,Sex=男动态的反序列化,ID=1,Name=关⽻,Age=2000,Sex=男#endregion#region 序列化List<Students> lstStuModel = new List<Students>(){new Students(){ID=1,Name="张飞",Age=250,Sex="男"},new Students(){ID=2,Name="潘⾦莲",Age=300,Sex="⼥"}};//序列化string jsonData = JsonConvert.SerializeObject(lstStuModel);Console.WriteLine(jsonData);//反序列化string json = @"{ 'Name':'C#','Age':'3000','ID':'1','Sex':'⼥'}";Students descJsonStu = JsonConvert.DeserializeObject<Students>(json);//反序列化Console.WriteLine(string.Format("反序列化: ID={0},Name={1},Sex={2},Sex={3}", descJsonStu.ID, , descJsonStu.Age, descJsonStu.Sex)); Console.ReadKey();输出结果[{"ID":1,"Name":"张飞","Age":250,"Sex":"男"},{"ID":2,"Name":"潘⾦莲","Age":300,"Sex":"⼥"}]反序列化: ID=1,Name=C#,Sex=3000,Sex=⼥#endregion}}}。
C#中的JSON序列化方法
C#中的JSON序列化⽅法在C#中的使⽤JSON序列化及反序列化时,推荐使⽤,当然也可以使⽤.NET⾃带的 System.Text.Json(.NET5)、DataContractJsonSerializer、JavaScriptSerializer(不推荐)。
下⾯是、DataContractJsonSerializer、JavaScriptSerializer的性能对⽐(来⾃官⽹):的扩展⽅法类如下(需引⽤Newtonsoft.Json命名空间):using Newtonsoft.Json;/// <summary>/// Newtonsoft.Json的扩展⽅法类/// </summary>public static class NewtonsoftJsonExtension{/// <summary>/// 将Json字符串反序列化为对象实例——Newtonsoft.Json/// </summary>/// <typeparam name="T">对象类型</typeparam>/// <param name="jsonString">Json字符串</param>/// <returns>对象实例</returns>public static T DeserializeObjectFromJson_NJ<T>(this string jsonString){return JsonConvert.DeserializeObject<T>(jsonString);}/// <summary>/// 将对象实例序列化为Json字符串——Newtonsoft.Json/// </summary>/// <typeparam name="T">对象类型</typeparam>/// <param name="obj">对象实例</param>/// <returns>Json字符串</returns>public static string SerializeObjectToJson_NJ<T>(this T obj){return JsonConvert.SerializeObject(obj);}}DataContractJsonSerializer的扩展⽅法类如下(需引⽤System.Runtime.Serialization.Json命名空间):using System;using System.Collections.Generic;using System.IO;using System.Runtime.Serialization.Json;using System.Text;/// <summary>/// System.Runtime.Serialization.Json扩展⽅法类([DataContract]和[DataMember]联合使⽤来标记被序列化的字段)/// </summary>public static class SerializationJsonExtension{private static Dictionary<Type, DataContractJsonSerializer> serDic = new Dictionary<Type, DataContractJsonSerializer>();private static DataContractJsonSerializer GetSerializer(Type type){if (!serDic.ContainsKey(type)){serDic.Add(type, new DataContractJsonSerializer(type));}return serDic[type];}/// <summary>/// 将Json字符串反序列化为对象实例——System.Runtime.Serialization.Json([DataContract]和[DataMember]联合使⽤来标记被序列化的字段) /// </summary>/// <typeparam name="T">对象类型</typeparam>/// <param name="jsonString">Json字符串</param>/// <returns>对象实例</returns>public static T DeserializeObjectFromJson_SJ<T>(this string jsonString){var ser = GetSerializer(typeof(T));using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString))){T jsonObject = (T)ser.ReadObject(ms);return jsonObject;}}/// <summary>/// 将对象实例序列化为Json字符串——System.Runtime.Serialization.Json([DataContract]和[DataMember]联合使⽤来标记被序列化的字段) /// </summary>/// <typeparam name="T">对象类型</typeparam>/// <param name="obj">对象实例</param>/// <returns>Json字符串</returns>public static string SerializeObjectToJson_SJ<T>(this T obj) {var ser = GetSerializer(typeof(T));using (var ms = new MemoryStream()){ser.WriteObject(ms, obj);ms.Position = 0;using (var sr = new StreamReader(ms, Encoding.UTF8)) {return sr.ReadToEnd();}}}}。
datacontractjsonserializer 序列化数组 -回复
datacontractjsonserializer 序列化数组-回复如何使用DataContractJsonSerializer来序列化和反序列化数组。
在现代软件开发中,数据序列化是一个常见的任务。
它可以让我们将数据转换为可传输或可存储的格式,以便在需要的时候重新恢复。
在C#中,我们可以使用DataContractJsonSerializer类来实现JSON(JavaScript Object Notation)数据的序列化和反序列化。
本文将重点介绍如何使用DataContractJsonSerializer来序列化和反序列化数组。
1. 引入命名空间在开始之前,我们需要在代码文件的顶部引入System.Runtime.Serialization命名空间。
这样我们才能使用DataContractJsonSerializer类和相关的特性。
2. 创建实体类在序列化和反序列化过程中,我们需要一个C#类来表示要转换的数据。
创建一个名为Person的类,并在其中添加一些属性来表示人的信息。
csharp[DataContract]public class Person{[DataMember]public string Name { get; set; }[DataMember]public int Age { get; set; }public Person(string name, int age){Name = name;Age = age;}}在这个例子中,我们使用了DataContract和DataMember特性。
DataContract特性用于标记该类是可序列化的,而DataMember特性用于标记要序列化的属性。
3. 序列化数组现在我们来看看如何使用DataContractJsonSerializer来序列化数组。
假设我们有一个名为people的Person数组,它包含了多个人的信息。
我们可以通过以下步骤将这个数组序列化为JSON字符串。
datacontractjsonserializer路径
datacontractjsonserializer路径一、什么是DataContractJsonSerializer1.1 DataContractJsonSerializer的定义DataContractJsonSerializer是.NET Framework中的一个类,用于在对象和JSON字符串之间进行序列化和反序列化。
1.2 DataContractJsonSerializer的特点•DataContractJsonSerializer可以将对象序列化为JSON字符串,也可以将JSON字符串反序列化为对象。
•DataContractJsonSerializer遵循.NET中的数据契约(DataContract)和数据成员(DataMember)的规范。
•DataContractJsonSerializer支持对复杂类型、嵌套类型和集合类型进行序列化和反序列化。
•DataContractJsonSerializer提供了丰富的选项和设置,以满足不同的序列化需求。
二、DataContractJsonSerializer的使用2.1 序列化对象为JSON字符串要使用DataContractJsonSerializer将对象序列化为JSON字符串,需要按照以下步骤进行操作: 1. 创建要序列化的对象实例。
2. 创建一个MemoryStream对象,用于存储序列化后的JSON数据。
3. 创建DataContractJsonSerializer实例,并将对象类型作为构造函数的参数。
4. 调用DataContractJsonSerializer的WriteObject方法,将对象序列化为JSON字符串,并将其写入MemoryStream中。
5. 使用Encoding类将MemoryStream中的数据转换为字符串。
2.2 反序列化JSON字符串为对象要使用DataContractJsonSerializer将JSON字符串反序列化为对象,需要按照以下步骤进行操作: 1. 创建一个MemoryStream对象,用于存储JSON字符串的字节流。
jsonserializer 使用
jsonserializer 使用JsonSerializer是一个用于将对象序列化为JSON格式的工具。
JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,广泛用于Web应用程序之间的数据传输。
JsonSerializer通过将对象转换为JSON字符串,使得对象的数据可以方便地在不同的系统之间传递和解析。
在使用JsonSerializer之前,我们需要先了解一些基本的概念。
首先是对象的序列化和反序列化。
序列化指的是将对象转换为一种可以存储或传输的格式,比如JSON字符串。
而反序列化则是将这种格式的数据转换回对象。
JsonSerializer提供了一系列的方法,可以轻松地实现对象的序列化和反序列化。
使用JsonSerializer的第一步是引入相关的库或包。
在不同的编程语言中,可能需要引入不同的库来支持JSON的序列化和反序列化。
比如在Java中,可以使用Jackson或Gson这样的库;在Python 中,可以使用json模块。
无论使用哪种语言和库,我们都需要先安装和导入相应的依赖。
接下来,我们需要定义一个对象,并给它赋予一些属性值。
这些属性可以是基本数据类型,也可以是其他对象。
我们可以使用JsonSerializer提供的方法,将这个对象转换为JSON字符串。
转换后的字符串可以通过网络传输,也可以存储到磁盘上。
在进行对象转换时,我们可以通过一些配置选项来控制转换的行为。
比如,我们可以指定只包含某些属性,或者排除某些属性;还可以指定日期的格式,或者设置缩进等。
这些选项可以根据具体的需求进行调整。
除了将对象转换为JSON字符串,JsonSerializer还可以将JSON 字符串转换回对象。
这个过程称为反序列化。
反序列化时,需要提供JSON字符串和目标对象的类型。
JsonSerializer会根据字符串的内容,将数据解析为对应的对象。
JsonSerializer的使用不限于对象的序列化和反序列化,还可以对JSON数据进行操作和处理。
datacontractjsonserializer 序列化数组
datacontractjsonserializer 序列化数组DataContractJsonSerializer是.NET 中用于将对象序列化为JSON 格式的类。
如果你想序列化数组,你需要创建一个包含该数组的对象,然后将该对象序列化。
以下是一个使用DataContractJsonSerializer序列化数组的简单示例:1.定义你想要序列化的对象:csharp复制代码[DataContract]public class MyData{[DataMember]public int Value { get;set; }}2.创建一个包含数组的对象:csharp复制代码List<MyData> myDataList = newList<MyData>{new MyData { Value = 1 },new MyData { Value = 2 },new MyData { Value = 3 }};3.序列化这个对象:csharp复制代码using (var memoryStream = new MemoryStream()){var serializer = newDataContractJsonSerializer(typeof(List<MyData>));serializer.WriteObject(memoryStream, myDataList);memoryStream.Position = 0;StreamReader reader = newStreamReader(memoryStream);string json = reader.ReadToEnd();Console.WriteLine(json); // 输出 JSON 格式的字符串}在这个例子中,MyData类的实例被创建并添加到一个列表中,然后该列表被序列化为JSON 格式。
输出将是包含数组的JSON 字符串。
wcf datacontractjsonserializersettings
wcf datacontractjsonserializersettingsWCF (Windows Communication Foundation) 是微软提供的一种用于构建和运行服务的框架,DataContractJsonSerializer是WCF中用于JSON序列化和反序列化的类。
在使用DataContractJsonSerializer时,有时需要对它的行为进行配置。
DataContractJsonSerializerSettings类就是用来设置这些配置的一个类。
通过这个类,可以配置DataContractJsonSerializer的行为,包括如何处理日期格式、如何序列化属性名等等。
下面是一些常用的设置:1. DateTimeFormat:用于设置日期格式。
如果设置为null,则日期格式将由.NET运行时环境决定。
2. IgnoreExtensionDataObject:一个布尔值,指示是否应跳过DataContractJsonSerializer处理的附加数据。
3. ItemCountLimit:一个整数,指示在单个JSON数组中可以包含多少个项。
默认情况下,此值为1000000。
4. MaxJsonArrayLength:一个整数,指示单个JSON数组可以包含的项的最大数量。
默认情况下,此值为1000000。
5. UseSimpleDictionaryFormat:一个布尔值,指示是否应使用简单字典格式进行序列化。
如果为true,则JSON将使用"{key:value}"格式而不是"{[key]:value}"格式。
6. SerializationBinder:一个类,用于提供自定义的绑定逻辑,用于控制如何将类型映射到其序列化表示形式。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、JSON简介JSON(JavaScript Object Notation,JavaScript对象表示法)是一种轻量级的数据交换格式。
JSON是“名值对”的集合。
结构由大括号'{}',中括号'[]',逗号',',冒号':',双引号'“”'组成,包含的数据类型有Object,Number,Boolean,String,Array, NULL等。
JSON具有以下的形式:对象(Object)是一个无序的“名值对”集合,一个对象以”{”开始,”}”结束。
每个“名”后跟着一个”:”,多个“名值对”由逗号分隔。
如:{"FirstName":"Jason","LastName":"Chen"}数组(Array)是值的有序集合,一个数组以“[”开始,以“]”结束,值之间使用“,”分隔。
如:[{"FirstName":"Jason","LastName":"Chen"},{"FirstName":"Jason","LastName":"C hen"}]字符串(String)是由双引号包围的任意数量的Unicode字符的集合,使用反斜线转义。
二、对JSON数据进行序列化和反序列化可以使用DataContractJsonSerializer类将类型实例序列化为JSON字符串,并将JSON 字符串反序列化为类型实例。
利用DataContractJsonSerializer序列化和反序列化的代码:using;using.;using...;using.;using..;/** DataContractJsonSerializer在System.Runtime.Serialization.Json命名空间下,* .NET Framework 3.5包含在System.ServiceModel.Web.dll中;* .NET Framework 4.0包含在System.Runtime.Serialization中。
* create by cjj on 2014-10-08;email:ijasonchen91@*/namespace.{/// <summary>/// JSON序列化和反序列化辅助类/// </summary>public class JsonHelper{/// <summary>/// JSON序列化/// </summary>/// <typeparam name="T"></typeparam>/// <param name="t"></param>/// <returns></returns>public static string<>(T ){DataContractJsonSerializer=newDataContractJsonSerializer(typeof(T));MemoryStream=new MemoryStream();.(, );string=Encoding..(.());.();=();return;}/// <summary>/// JSON反序列化/// </summary>/// <typeparam name="T"></typeparam>/// <param name="jsonString"></param>/// <returns></returns>public static T <>(string){=();DataContractJsonSerializer=newDataContractJsonSerializer(typeof(T));MemoryStream=new MemoryStream(Encoding..()); T = (T).();.();return;}/// <summary>/// 将"\/Date(673286400000+0800)\/"Json时间格式替换"yyyy-MM-dd HH:mm:ss"格式的字符串/// </summary>/// <param name="jsonDateTimeString">"\/Date(673286400000+0800)\/"Json时间格式</param>/// <returns></returns>private static string(string){string=string.;string=@"\\/Date\((\d+)\+\d+\)\\/";MatchEvaluator=newMatchEvaluator();Regex=new Regex();=.(, );return;}private static string(Match){string=string.;DateTime=new DateTime(1970, 1, 1);=.(long.(.[1].));=.();=.("yyyy-MM-dd HH:mm:ss");return;}/// <summary>/// 将"yyyy-MM-dd HH:mm:ss"格式的字符串替换"\/Date(673286400000+0800)\/"Json时间格式/// </summary>/// <param name="dateTimeString">"yyyy-MM-dd HH:mm:ss"格式的字符串</param>/// <returns></returns>private static string(string){string=string.;string=@"\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}";MatchEvaluator=newMatchEvaluator();Regex=new Regex();=.(, );return;}private static string(Match){string=string.;DateTime=DateTime.(.[0].);=.();TimeSpan=-DateTime.("1970-01-01");=string.("\\/Date({0}+0800)\\/", .);return;}}序列化Demo:简单对象Person:[DataContract]public class Person{public() { }public(string, string, DateTime){this.=;this.=;this.=;}[DataMember]public string { get; set; }[DataMember]public string { get; set; }[DataMember]public DateTime { get; set; }}序列化为JSON字符串:private void(){Person=new Person("Jason", "Chen", Convert.("1991-05-04"));string=JsonHelper.<Person>();.();}输出结果:{"Birthday":"1991-05-04 00:00:00","FirstName":"Jason","LastName":"Chen"}反序列化Demo:private static void(){string="{\"FirstName\":\"Jason\",\"LastName\":\"Chen\",\"Birthday\":\"1991-05-04 00:00:00\"}";Person=JsonHelper.<Person>();}三、JSON序列化集合、字典、数组的处理在JSON数据中,所有的集合、字典和数组都表示为数组。
List<T>序列化:private void Serialize(){List<Person>list=new List<Person>(){new Person("Jason", "Chen", Convert.ToDateTime("1991-05-04")),new Person("Jack", "Chen", Convert.ToDateTime("1991-05-05"))};string jsonString=JsonHelper.Serialize<List<Person>>(list);Response.Write(jsonString);}序列化结果:[{"Birthday":"1991-05-0400:00:00","FirstName":"Jason","LastName":"Chen"},{"Birthday":"1991-05-05 00:00:00","FirstName":"Jack","LastName":"Chen"}]Dictionary字典转化为JSON并不是跟原来的字典格式一致,而是形式以Dictionary的Key 作为名称”Key“的值,以Dictionary的Value作为名称为”Value“的值。