什么是序列化和反序列

net的运行时环境用来支持用户定义类型的流化的机制。它是将对象实例的状态存储到存储媒体的过程。在此过程中，先将对象的公共字段和私有字段以及类的名称（包括类所在的程序集）转换为字节流，然后再把字节流写入数据流。在随后对对象进行反序列化时，将创建出与原对象完全相同的副本。

序列化的目的:
1、以某种存储形式使自定义对象持久化；
2、将对象从一个地方传递到另一个地方。

实质上序列化机制是将类的值转化为一个一般的（即连续的）字节流，然后就可以将该流写到磁盘文件或任何其他流化目标上。而要想实际的写出这个流，就要使用那些实现了IFormatter接口的类里的Serialize和Deserialize方法。
在.net框架里提供了这样两个类：

一、BinaryFormatter

BinaryFormatter使用二进制格式化程序进行序列化。您只需创建一个要使用的流和格式化程序的实例，然后调用格式化程序的 Serialize 方法。流和要序列化的对象实例作为参数提供给此调用。类中的所有成员变量（甚至标记为 private 的变量）都将被序列化。

首先我们创建一个类：

1. [Serializable]    
2.   public   class   MyObject   {    
3.       public   int   n1   =   0;    
4.       public   int   n2   =   0;    
5.       public   String   str   =   null;    
6.   }    

Serializable属性用来明确表示该类可以被序列化。同样的，我们可以用NonSerializable属性用来明确表示类不能被序列化。
接着我们创建一个该类的实例，然后序列化，并存到文件里持久：   

1. MyObject   obj   =   new   MyObject();    
2.   obj.n1   =   1;    
3.   obj.n2   =   24;    
4.   obj.str   =   "一些字符串";    
5.   IFormatter   formatter   =   new   BinaryFormatter();    
6.   Stream   stream   =   new   FileStream("MyFile.bin",   FileMode.Create,      
7.   FileAccess.Write,   FileShare.None);    
8.   formatter.Serialize(stream,   obj);    
9.   stream.Close();    

 而将对象还原到它以前的状态也非常容易。首先，创建格式化程序和流以进行读取，然后让格式化程序对对象进行反序列化。   

1. IFormatter   formatter   =   new   BinaryFormatter();    
2.   Stream   stream   =   new   FileStream("MyFile.bin",   FileMode.Open,      
3.   FileAccess.Read,   FileShare.Read);    
4.   MyObject   obj   =   (MyObject)   formatter.Deserialize(fromStream);    
5.   stream.Close();    
6.      
7.   //   下面是证明    
8.   Console.WriteLine("n1:   {0}",   obj.n1);    
9.   Console.WriteLine("n2:   {0}",   obj.n2);    
10.   Console.WriteLine("str:   {0}",   obj.str); 

二、SoapFormatter

前面我们用BinaryFormatter以二进制格式来序列化。很容易的我们就能把前面的例子改为用SoapFormatter的，这样将以xml格式化，因此能有更好的可移植性。所要做的更改只是将以上代码中的格式化程序换成 SoapFormatter，而 Serialize 和 Deserialize 调用不变。对于上面使用的示例，该格式化程序将生成以下结果。   

1. <SOAP-ENV:Envelope    
2.       xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance    
3.       xmlns:xsd="http://www.w3.org/2001/XMLSchema"      
4.       xmlns:SOAP-   ENC=http://schemas.xmlsoap.org/soap/encoding/    
5.       xmlns:SOAP-   ENV=http://schemas.xmlsoap.org/soap/envelope/    
6.       SOAP-ENV:encodingStyle=    
7.       "http://schemas.microsoft.com/soap/encoding/clr/1.0    
8.       http://schemas.xmlsoap.org/soap/encoding/"    
9.       xmlns:a1="http://schemas.microsoft.com/clr/assem/ToFile">    
10.      
11.       <SOAP-ENV:Body>    
12.           <a1:MyObject  >    
13.               <n1>1</n1>    
14.               <n2>24</n2>    
15.               <str  >一些字符串</str>    
16.           </a1:MyObject>    
17.       </SOAP-ENV:Body>    
18.   </SOAP-ENV:Envelope>    

在这里需要注意的是，无法继承 Serializable 属性。如果从 MyObject 派生出一个新的类，则这个新的类也必须使用该属性进行标记，否则将无法序列化。例如，如果试图序列化以下类实例，将会显示一个 SerializationException，说明 MyStuff 类型未标记为可序列化。

1. public   class   MyStuff   :   MyObject      
2.   {    
3.       public   int   n3;    
4.   }    

然而关于格式化器，还有个问题，假设我们只需要xml，但不需要soap特有的额外信息，那么该怎么做？有两个方案：1、编写一个实现IFormatter接口的类，采用的方式类似于SoapFormatter，但是可以没有你不需要的信息；2、使用框架提供的类XmlSerializer。
XmlSerializer类和前两个主流的序列化类的几个不同点是：
1、不需要Serializable属性，Serializable和NonSerializable属性将会被忽略，但是使用XmlIgnore属性，和NonSerializable属性类似。
2、该类不能安全地访问私有变成员，所以学要将私有成员改为公共成员，或者提供合适的公共特性。
3、要求被序列化的类要有一个默认的构造器。

我们改一下前面的MyObject类为：   

1. public   class   MyObject   {    
2.       public   int   n1;    
3.       public   String   str;    
4.       public   MyObject(){}    
5.       public   MyObject(n1,str)    
6.       {    
7.     this.n1=n1;    
8.     this.str=str;    
9.       }    
10.       public   override   string   ToString()    
11.       {    
12.     return   String.Format("{0}:{1}",this.str,this.n1);    
13.       }    
14.   }    

现在我们用XmlSerializer类来对修改后的MyObject进行序列化。因为XmlSerializer类的构造器里有个Type参数，所以XmlSerializer对象被明确的 连到该Type参数所表示的类了。XmlSerializer类也有Serialize和Deserialize方法：   

1. MyObject   obj   =   new   MyObject(12,"some   string");    
2.   XmlSerializer   formatter   =   new   XmlSerializer(typeof(MyObject));    
3.   Stream   stream   =   new   FileStream("MyFile.xml",   FileMode.Create,      
4.   FileAccess.Write,   FileShare.None);    
5.   formatter.Serialize(stream,   obj);    
6.   //下面是反序列化    
7.   stream.Seek(0,SeekOrigin.Begin)    
8.   MyObject   obj_out=(MyObject)formatter.Deserialize(stream)    
9.   stream.Close();    
10.   Console.WriteLine(obj_out);   

 这个简单的列子可以加以扩展，以便利用更多的XmlSerializer功能，包括使用属性控制xml标记、使用xml模式和进行soap编码。

自定义序列化

如果你希望让用户对类实现序列化，但是对数据流的组织方式不完全满意，那么可以通过在对象上实现 ISerializable 接口来自定义序列化过程。这一功能在反序列化后成员变量的值失效时尤其有用，但是需要为变量提供值以重建对象的完整状态。除了必须将类申明为 Serializable 的同时，还要要实现 ISerializable接口，需要实现 GetObjectData 方法以及一个特殊的构造函数，在反序列化对象时要用到此构造函数。在实现 GetObjectData 方法时，最常调用的SerializationInfo的方法是AddValue，这个方法具有针对所有标准类型（int、char等等）的重载版本；而 StreamingContext 参数描述给定的序列化流的源和目标，这样我们就可以知道我们是将对象序列化到持久性存储还是在将他们跨进程或机器序列化。而在反序列化时，我们调用SerializationInfo提供的一组Getxxx方法，他们针对所有标准类型数据执行各种AddValue重载版本的逆操作。下代码示例说明了如何在前一部分中提到的 MyObject 类上实现 ISerializable。   

1. [Serializable]    
2.   public   class   MyObject   :   ISerializable      
3.   {    
4.       public   int   n1;    
5.       public   int   n2;    
6.       public   String   str;    
7.      
8.       public   MyObject()    
9.       {    
10.       }    
11.      
12.       protected   MyObject(SerializationInfo   info,   StreamingContext   context)    
13.       {    
14.           n1   =   info.GetInt32("i");    
15.           n2   =   info.GetInt32("j");    
16.           str   =   info.GetString("k");    
17.       }    
18.      
19.       public   virtual   void   GetObjectData(SerializationInfo   info,      
20.   StreamingContext   context)    
21.       {    
22.           info.AddValue("i",   n1);    
23.           info.AddValue("j",   n2);    
24.           info.AddValue("k",   str);    
25.       }    
26.   }    

在序列化过程中调用 GetObjectData 时，需要填充方法调用中提供的 SerializationInfo 对象。只需按名称/值对的形式添加将要序列化的变量。其名称可以是任何文本。只要已序列化的数据足以在反序列化过程中还原对象，便可以自由选择添加至 SerializationInfo 的成员变量。如果基对象实现了 ISerializable，则派生类应调用其基对象的 GetObjectData 方法。

需要强调的是，将 ISerializable 添加至某个类时，需要同时实现 GetObjectData 以及特殊的具有特定原型的构造函数－－重要的是，该构造函数的参数列表必须与GetObjectData相同，这个构造函数将会在反序列化的过程中使用：格式化器从流中反序列化数据，然后通过这个构造函数对对象进行实列化。如果缺少 GetObjectData，编译器将发出警告。但是，由于无法强制实现构造函数，所以，缺少构造函数时不会发出警告。如果在没有构造函数的情况下尝试反序列化某个类，将会出现异常。在消除潜在安全性和版本控制问题等方面，当前设计优于 SetObjectData 方法。例如，如果将 SetObjectData 方法定义为某个接口的一部分，则此方法必须是公共方法，这使得用户不得不编写代码来防止多次调用 SetObjectData 方法。可以想象，如果某个对象正在执行某些操作，而某个恶意应用程序却调用此对象的 SetObjectData 方法，将会引起一些潜在的麻烦。

在反序列化过程中，使用出于此目的而提供的构造函数将 SerializationInfo 传递给类。对象反序列化时，对构造函数的任何可见性约束都将被忽略，因此，可以将类标记为 public、protected、internal 或 private。一个不错的办法是，在类未封装的情况下，将构造函数标记为 protect。如果类已封装，则应标记为 private。要还原对象的状态，只需使用序列化时采用的名称，从 SerializationInfo 中检索变量的值。如果基类实现了 ISerializable，则应调用基类的构造函数，以使基础对象可以还原其变量。