JSON（序列化与反序列化）[Serializable]在C#中的作用-NET中的对象序列化 ...

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Node.js›Node.js教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

最近公司项目中用到了Json操作，从.NET后台读取数据，通过Json转化在传给“Andiron”端呈现，于是通过几天的学习，对它有了一点的理解！

　　 1.Json的理解

　　　　Json其实就是一个序列化和反序列化的操作，而通过序列化操作之后的数据可以跨平台使用，这就促使了可以使用两个平台，一个做后台，一个做前台，数据访问层通过Json来传递！

　　2.可以序列化的标志　　　　

　　[Serializable]
public class MyPeople
{
public string Name { get; set; }
public string FatherName { get; set; }
　　 }

　　　　从上面代码可以看出要通过添加[Serializable]特性来标志这个对象是可以序列化的！　　　　

　　　　[NonSerialized] 特性，如果在你的属性上面加上这个特性，就表示这个属性将不会被序列化！

　　3.什么是序列化和可序列化

　　　　序列化首先从内存中把对象读取并通过一定方式进行序列化，然后通过流操作进行输出或保存！

反序列化首先会通过流操作读取出来，然后通过一定序列化方式转化流对象变成实体对象！

　　　　推荐文章 → [Serializable]在C#中的作用-NET 中的对象序列化

　　4.使用二进制(BinaryFormatter)进行序列化

　　　　4.1序列化

1 　　　 MyPeople myPeople = new MyPeople() { Name = "yangcaogui", FatherName = "caoxiaolong" };
2       IFormatter binaryFormatter = new BinaryFormatter();
3       using (Stream stream = new FileStream("one.txt", FileMode.Create, FileAccess.Write, FileShare.None))  //也可以使用MemoryStream内存流
4       {
5             binaryFormatter.Serialize(stream, myPeople);
6             stream.Close();
7       }

　　　　4.2反序列化

　　 IFormatter binaryFormatter = new BinaryFormatter();
using (Stream streamOne = new FileStream("one.txt", FileMode.Open, FileAccess.Read, FileShare.None))
{
MyPeople myPeopleOne = (MyPeople)binaryFormatter.Deserialize(streamOne);
Console.WriteLine(myPeopleOne.Name + "\t" + myPeopleOne.FatherName);
}

　　5.使用SoapFormatter进行序列化

　　　　这个跟二进制序列化不一样的地方是 → 最后的数据是以XML的形式存在！

　　　　5.1序列化

　　　　5.2反序列化

　　　　　　基本代码跟二进制反序列化一样的，就不贴出来了！

　　6.使用XmlSerializer序列化　　　　

　　　　它使用的范围比较广，都可以对“DataContract”和“Serializable”标志的对象进行序列化和反序列化的操作！

　　　　它可以对一个“XML”的文件进行序列化！　　　

　　　　6.1序列化　

1 　　　　XmlSerializer xmlSerializer = new XmlSerializer(typeof(My));
2 　　　　using (MemoryStream memoryStream = new MemoryStream())
3 　　　　{
4      　　　　xmlSerializer.Serialize(memoryStream, my);
5      　　　　Console.WriteLine("\n\n------------------4→XmlSerializer------------------------------------\n\n");
6      　　　　Console.WriteLine(Encoding.UTF8.GetString(memoryStream.ToArray()));
7 　　　　}

　　　　序列化格式如下：　　　　

　　　　6.2反序列化

　　　XmlSerializer xmlSerializer = new XmlSerializer(typeof (My));
using (MemoryStream memoryStreamOne = new MemoryStream(Encoding.UTF8.GetBytes(str), 0, str.Length)) // str 是我序列化之后的数据
{
My myOne = (My) xmlSerializer.Deserialize(memoryStreamOne);
Console.WriteLine("----------反序列化的结果------------------");
Console.WriteLine(myOne.Name + "\t" + myOne.NameOne);
}

　　7.DataContractSerializer，DataContractJsonSerializer，NetDataContractSerializer

　　　　Note：DataContractSerializer 和DataContractJsonSerializer 需要.NET Frameword 3.5才能使用！

　　　首先要序列化和反序列化的对象都要加上序列化的特性！　　

 1    [DataContract]
 2     public class My
 3     {
 4         [DataMember]
 5         public string Name { get; set; }
 6 
 7         [DataMember]
 8         public string NameOne { get; set; }
 9 
10         public string NameTwo { get; set; }
11     }

　　　　Note：首先通过流操作把对象(可以是XML，内存中的对象，文本等形式)读取出来，然后通过.NET Framework中的序列化算法把对象进行序列化！

　　　　下面就是这三种序列化的不同形式：

　　　　DataContractSerializer和NetDataContractSerializer序列化之后都是XML的格式，而DataContractJsonSerializer序列化之后就是常见的Json数据格式！

　　　　代码如下：

View Code

　　　　Note：除了XmlSerializer序列化调用的方法是“Deserialize”，其它的序列化都是使用“ReadObject”进行反序列化操作！

　　8.一般的Json数据格式　　　　

　　9.理解序列化操作　　　　

　　　　下午在写公共类库的时候发现序列化其实就是流操作和序列化算法的结合，不管你使用哪一种流操作，最重要的还是你使用的是哪一种序列化算法，有“BinaryFormatter”，“SoapFormatter”，“XmlSerializer”，“DataContractSerialize”，“DataContractJsonSerializer”，“NetDataContractSerializer” 等，它们在序列化之后的格式有一定的差异！

　　10.关于Json序列化时间的问题

　　　　没接触过不知道问题所在，接触过了才能猛然醒悟！

　　　　①如果把时间设置为“String”类型，如下：

　　　　②如果直接设置为“DataTime”，如下：

　　11.简单的封装Json操作类，解决时间问题

　　 public static class JsonOperation<T>
{
private static readonly DataContractJsonSerializer DataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
//序列化
public static string JsonSerializeOperation(T obj)
{
if (obj == null)
throw new Exception();
string str = "";
using (MemoryStream memoryStream = new MemoryStream())
{
DataContractJsonSerializer.WriteObject(memoryStream, obj);
str = Encoding.UTF8.GetString(memoryStream.ToArray());
}
return ConvertJsonTimeToDateTime(str);
}
//反序列化
public static T JsonDeserializeOperation(string str)
{
if (string.IsNullOrEmpty(str))
throw new Exception();
using (MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(str)))
{
return (T)DataContractJsonSerializer.ReadObject(memoryStream);
}
}
//二进制序列化
public static string BinarySerializeOperation(T obj)
{
string jsonString = "";
if (obj == null)
throw new Exception();
IFormatter formatter = new BinaryFormatter();
using (MemoryStream memoryStream = new MemoryStream())
{
formatter.Serialize(memoryStream, obj);
jsonString = Encoding.UTF8.GetString(memoryStream.ToArray());
}
return jsonString;
}
//二进制反序列化
public static T BinaryDeserializeOperation(string str)
{
if (string.IsNullOrEmpty(str))
throw new Exception();
IFormatter formatter = new BinaryFormatter();
using (MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(str)))
{
return (T)formatter.Deserialize(memoryStream);
}
}
/// <summary>
/// 把Json中的时间转化为正规时间，现在是Json数据格式，需要转化普通的时间格式 → yyyy-MM-dd HH:MM:ss
/// </summary>
/// <param name="jsonString">Json Time</param>
/// <returns></returns>
private static string ConvertJsonTimeToDateTime(string jsonString)
{
if (string.IsNullOrEmpty(jsonString))
throw new Exception();
const string matchDate = @"\\/Date\((\d+)\+\d+\)\\/";
Regex regex = new Regex(matchDate);
Match match = regex.Match(jsonString);
foreach (var matchValue in match.Groups)
{
if (matchValue is Match)
{
Match matchOne = (Match)matchValue;
DateTime dateTime = JsonOperation<DateTime>.JsonDeserializeOperation(string.Format("\"{0}\"", matchOne.Value)); // This is very important.
jsonString = jsonString.Replace(matchOne.Value, dateTime.ToString("yyyy-MM-dd HH-MM-ss"));
}
}
return jsonString;
}
}

[02] 学习的那些事