C#序列化和反序列化程序都是基于工厂模式下的，那么C#序列化和反序列化到底有什么不同之处么？那么本文就向你详细介绍C#序列化和反序列化程序的区别及其应用。
AD：
C#序列化和反序列化，两者的程序处理方式基本一致，都是基于工厂模式的，所谓C#序列化就是是将对象转换为容易传输的格式的过程，一般情况下转化打流文件，放入内存或者IO文件中。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象，或者和其它应用程序共享使用。相反的，反序列化根据流重新构造对象。.NET自带的有两种序列化对象的方式，Xml和binary的，XML 序列化不转换方法、索引器、私有字段或只读属性（只读集合除外）。要序列化对象的所有字段和属性（公共的和私有的），请使用 BinaryFormatter，而不要使用 XML 序列化。
C#序列化和反序列化的实例应用剖析：
二进制的C#序列化的方式：
例如我们有个对象:
- [Serializable]public class ClassToSerialize{
- public int id=100;
- public string name="Name";
- }
需要序列化该对象，必须在给该类加上Serializable的属性，然后创建一个序列化写入的流：FileStream fileStream = new FileStream("temp.dat", FileMode.Create);然后创建二进制格式器：BinaryFormatter b=new BinaryFormatter();然后是序列化：b.Serialize(fileStream,c);，然后关闭保存流。（可以见下面的例子）
读取一个已经被序列化的对象的时候：操作方式一样，只是
- FileStream fileStream = new FileStream(
- "temp.dat", FileMode.Open,
- FileAccess.Read, FileShare.Read);
- ClassToSerialize c =
- (ClassToSerialize)b.Deserialize(fileStream);
然后就可以读取了，完整的例子是：
- using System;
- using System.IO;
- using System.Runtime.Serialization;
- using System.Runtime.Serialization.Formatters.Binary;
- public class SerialTest{
- public void SerializeNow(){
- ClassToSerialize c=new ClassToSerialize();
- FileStream fileStream = new FileStream(
- "temp.dat", FileMode.Create);
- BinaryFormatter b=new BinaryFormatter();
- b.Serialize(fileStream,c);
- fileStream.Close();
- }
- public void DeSerializeNow(){
- ClassToSerialize c=new ClassToSerialize();
- FileStream fileStream = new FileStream(
- "temp.dat", FileMode.Open,
- FileAccess.Read,
- FileShare.Read);
- BinaryFormatter b=new BinaryFormatter();
- //SoapFormatter
- c=(ClassToSerialize)b.Deserialize(fileStream);
- Console.WriteLine(c.name);
- fileStream.Close();
- }
- public static void Main(string[] s){
- SerialTest st=new SerialTest();
- st.SerializeNow();
- st.DeSerializeNow();
- }
- }
- [Serializable]
- public class ClassToSerialize{
- public int id=100;
- public string name="Name";
- }
这就是自带的序列化和反序列的操作，但是，很多情况下，一个对象比较大，而且很多私有的属性和方法我们不需要，例如在原型模式里面序列化的话，只需要序列Clone方法和一些属性，私有的方法无需要，还例如在读取大规模的IO的时候，读取操作完全不需要... 这时候就需要自己集成重写序列的ISerializable接口：
实现该接口需要两个注意的，一个就是构造函数，主要是为了反序列，另一个就是GetObjectData，主要是执行序列化，例如我们现在有一个Employee类需要序列化
- [Serializable()]
- //Set this attribute to all the classes that want to serialize
- public class Employee : ISerializable
- //derive your class from ISerializable {
- public int EmpId;
- public string EmpName;
- [NonSerialized()]
- public string NoSerialString="NoSerialString-Test";
- }
需要注意的是我这里的NoSerialString属性前面有[NonSerialized()]，就是说默认并不序列化这个属性，而是使用默认值 。
首先是构造函数：
- public Employee(SerializationInfo info, StreamingContext ctxt)
- {
- EmpId = (int)info.GetValue(
- "EmployeeId", typeof(int));
- EmpName = (String)info.GetValue(
- "EmployeeName", typeof(string));
- //NoSerialString =
- //(String)info.GetValue("NoSerialString", typeof(string));
- }
然后是C#序列化方法，就是当写入流的时候怎么保存的：
- public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
- {
- //You can use any custom name for your name-value pair.
- // But make sure you
- // read the values with the same name.
- //For ex:- If you write EmpId as "EmployeeId"
- // then you should read the same with "EmployeeId"
- info.AddValue("EmployeeId", EmpId);
- info.AddValue("EmployeeName", EmpName);
- }
把上面两个方法写入到Employee类，然后写个测试的程序：
- public class ObjSerial{
- public static void Main(String[] args){
- Employee mp = new Employee();
- mp.EmpId = 10;
- mp.EmpName = "Omkumar";
- mp.NoSerialString = "你好啊";
- //C#序列化和反序列化之序列化
- Stream stream = File.Open("EmployeeInfo.osl", FileMode.Create);
- BinaryFormatter bformatter = new BinaryFormatter();
- Console.WriteLine("Writing Employee Information");
- bformatter.Serialize(stream, mp);
- stream.Close();
- mp = null;
- //C#序列化和反序列化之反序列
- stream = File.Open("EmployeeInfo.osl", FileMode.Open);
- bformatter = new BinaryFormatter();
- Console.WriteLine("Reading Employee Information");
- mp = (Employee)bformatter.Deserialize(stream);
- stream.Close();
- Console.WriteLine(
- "Employee Id: {0}",mp.EmpId.ToString());
- Console.WriteLine(
- "Employee Name: {0}",mp.EmpName);
- Console.WriteLine(
- "Employee NoSerialString: {0}",mp.NoSerialString);
- }
- }
C#序列化和反序列化程序执行的结果是：
- Writing Employee Information
- Reading Employee Information
- Employee Id: 10
- Employee Name: Omkumar
- Employee NoSerialString: NoSerialString-Test
看到Employee NoSerialString:属性的值没有，它保持默认值，没有序列化。
C#序列化和反序列化的理解就向你介绍到这里，希望对你了解和学习更重要的是对你使用C#序列化和反序列化有所帮助。
对象的Xml序列化和反序列化
这篇随笔对应的.Net命名空间是System.Xml.Serialization；文中的示例代码需要引用这个命名空间。
为什么要做序列化和反序列化？
.Net程序执行时，对象都驻留在内存中；内存中的对象如果需要传递给其他系统使用；或者在关机时需要保存下来以便下次再次启动程序使用就需要序列化和反序列化。
范围：本文只介绍xml序列化，其实序列化可以是二进制的序列化，也可以是其他格式的序列化。
看一段最简单的Xml序列化代码class Program
{
static void Main(string[] args)
{
int i = 10;
//声明Xml序列化对象实例serializer
XmlSerializer serializer = new XmlSerializer(typeof(int));
//执行序列化并将序列化结果输出到控制台
serializer.Serialize(Console.Out, i);
Console.Read();
}
}
上面代码对int i进行了序列化，并将序列化的结果输出到了控制台，输出结果如下<?xml version="1.0" encoding="gb2312"?>
<int>10</int>
可以将上述序列化的xml进行反序列化，如下代码static void Main(string[] args)
{
using (StringReader rdr = new StringReader(@"<?xml version=""1.0"" encoding=""gb2312""?>
<int>10</int>"))
{
//声明序列化对象实例serializer
XmlSerializer serializer = new XmlSerializer(typeof(int));
//反序列化，并将反序列化结果值赋给变量i
int i = (int)serializer.Deserialize(rdr);
//输出反序列化结果
Console.WriteLine("i = " + i);
Console.Read();
}
}以上代码用最简单的方式说明了xml序列化和反序列化的过程，.Net系统类库为我们做了大量的工作，序列化和反序列化都非常简单。但是在现实中业务需求往往比较复杂，不可能只简单的序列化一个int变量，显示中我们需要对复杂类型进行可控制的序列化。
自定义对象的Xml序列化：
System.Xml.Serialization命名空间中有一系列的特性类，用来控制复杂类型序列化的控制。例如XmlElementAttribute、XmlAttributeAttribute、XmlArrayAttribute、XmlArrayItemAttribute、XmlRootAttribute等等。
看一个小例子，有一个自定义类Cat，Cat类有三个属性分别为Color，Saying，Speed。
namespace UseXmlSerialization
{
class Program
{
static void Main(string[] args)
{
//声明一个猫咪对象
var c = new Cat { Color = "White", Speed = 10, Saying = "White or black, so long as the cat can catch mice, it is a good cat" };
//序列化这个对象
XmlSerializer serializer = new XmlSerializer(typeof(Cat));
//将对象序列化输出到控制台
serializer.Serialize(Console.Out, c);
Console.Read();
}
}
[XmlRoot("cat")]
public class Cat
{
//定义Color属性的序列化为cat节点的属性
[XmlAttribute("color")]
public string Color { get; set; }
//要求不序列化Speed属性
[XmlIgnore]
public int Speed { get; set; }
//设置Saying属性序列化为Xml子元素
[XmlElement("saying")]
public string Saying { get; set; }
}
}可以使用XmlElement指定属性序列化为子节点（默认情况会序列化为子节点）；或者使用XmlAttribute特性制定属性序列化为Xml节点的属性；还可以通过XmlIgnore特性修饰要求序列化程序不序列化修饰属性。
对象数组的Xml序列化：
数组的Xml序列化需要使用XmlArrayAttribute和XmlArrayItemAttribute；XmlArrayAttribute指定数组元素的Xml节点名，XmlArrayItemAttribute指定数组元素的Xml节点名。
如下代码示例：/*玉开技术博客 http://www.cnblogs.com/yukaizhao */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
namespace UseXmlSerialization
{
class Program
{
static void Main(string[] args)
{
//声明一个猫咪对象
var cWhite = new Cat { Color = "White", Speed = 10, Saying = "White or black, so long as the cat can catch mice, it is a good cat" };
var cBlack = new Cat { Color = "Black", Speed = 10, Saying = "White or black, so long as the cat can catch mice, it is a good cat" };
CatCollection cc = new CatCollection { Cats = new Cat[] { cWhite,cBlack} };
//序列化这个对象
XmlSerializer serializer = new XmlSerializer(typeof(CatCollection));
//将对象序列化输出到控制台
serializer.Serialize(Console.Out, cc);
Console.Read();
}
}
[XmlRoot("cats")]
public class CatCollection
{
[XmlArray("items"),XmlArrayItem("item")]
public Cat[] Cats { get; set; }
}
[XmlRoot("cat")]
public class Cat
{
//定义Color属性的序列化为cat节点的属性
[XmlAttribute("color")]
public string Color { get; set; }
//要求不序列化Speed属性
[XmlIgnore]
public int Speed { get; set; }
//设置Saying属性序列化为Xml子元素
[XmlElement("saying")]
public string Saying { get; set; }
}
}
以上代码将输出：<?xml version="1.0" encoding="gb2312"?>
<cats xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://ww
w.w3.org/2001/XMLSchema">
<items>
<item color="White">
<saying>White or black, so long as the cat can catch mice, it is a good
cat</saying>
</item>
<item color="Black">
<saying>White or black, so long as the cat can catch mice, it is a good
cat</saying>
</item>
</items>
</cats>
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
