C#序列化详解

不念不忘少年蓝@ 2022-08-27 01:18 172阅读 0赞

.net的运行时环境用来支持用户定义类型的流化的机制。它是将对象实例的状态[存储][Link 1]到存储媒体的过程。在此过程中，先将对象的公共字段和私有字段以及类的名称（包括类所在的程序集）转换为字节流，然后再把字节流写入数据流。在随后对对象进行反序列化时，将创建出与原对象完全相同的副本。  
  
  序列化的目的:  
  
  1、以某种存储形式使自定义对象持久化；  
  
  2、将对象从一个地方传递到另一个地方。  
  
  实质上序列化机制是将类的值转化为一个一般的（即连续的）字节流，然后就可以将该流写到磁盘文件或任何其他流化目标上。而要想实际的写出这个流，就要使用那些实现了IFormatter接口的类里的Serialize和Deserialize方法。  
  
  在.net框架里提供了这样两个类：  
  
  一、BinaryFormatter  
  
  BinaryFormatter使用二进制格式化程序进行序列化。您只需创建一个要使用的流和格式化程序的实例，然后调用格式化程序的 Serialize 方法。流和要序列化的对象实例作为参数提供给此调用。类中的所有成员变量（甚至标记为 private 的变量）都将被序列化。  
  
  首先我们创建一个类：

\[Serializable\]

public class MyObject \{

public int n1 = 0;

public int n2 = 0;

public String str =  null;

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

MyObject obj = new MyObject();

obj.n1 = 1;

obj.n2 = 24;

obj.str = "一些字符串";

IFormatter formatter = new BinaryFormatter();

Stream stream = new FileStream("MyFile.bin",FileMode.Create,

FileAccess.Write, FileShare.None);

formatter.Serialize(stream, obj);

stream.Close();

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

IFormatter formatter = new BinaryFormatter();

Stream stream = new FileStream("MyFile.bin",FileMode.Open,

FileAccess.Read, FileShare.Read);

MyObject obj = (MyObject) formatter.Deserialize(fromStream);

stream.Close();

// 下面是证明

Console.WriteLine("n1: \{0\}", obj.n1);

Console.WriteLine("n2: \{0\}", obj.n2);

Console.WriteLine("str: \{0\}", obj.str);

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

<SOAP-ENV:Envelope

xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance

xmlns:xsd="http://www.w3.org/2001/XMLSchema"

xmlns:SOAP-ENC=http://schemas.xmlsoap.org/soap/encoding/

xmlns:SOAP-ENV=http://schemas.xmlsoap.org/soap/envelope/

SOAP-ENV:encodingStyle=

"http://schemas.microsoft.com/soap/encoding/clr/1.0

http://schemas.xmlsoap.org/soap/encoding/"

xmlns:a1="http://schemas.microsoft.com/clr/assem/ToFile">

<SOAP-ENV:Body>

<a1:MyObject id="ref-1">

<str  id="ref-3">一些字符串</str>

</a1:MyObject>

</SOAP-ENV:Body>

</SOAP-ENV:Envelope>

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

public  class MyStuff : MyObject

public int n3;

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

public  class MyObject \{

public int n1;

public String str;

public MyObject()\{\}

public MyObject(n1,str)

this.n1=n1;

this.str=str;

public override string ToString()

return String.Format("\{0\}:\{1\}",this.str,this.n1);

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

MyObject obj = new MyObject(12,"some string...");

XmlSerializer formatter = new XmlSerializer(typeof(MyObject));

Stream stream = new FileStream("MyFile.xml",FileMode.Create,

FileAccess.Write, FileShare.None);

formatter.Serialize(stream, obj);

//下面是反序列化

stream.Seek(0,SeekOrigin.Begin)

MyObject obj\_out=(MyObject)formatter.Deserialize(stream)

stream.Close();

Console.WriteLine(obj\_out);

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

\[Serializable\]

public class MyObject : ISerializable

public int n1;

public int n2;

public String str;

public MyObject()

protected MyObject(SerializationInfo info,StreamingContext context)

n1 = info.GetInt32("i");

n2 = info.GetInt32("j");

str = info.GetString("k");

public virtual void GetObjectData(SerializationInfo info,

StreamingContext context)

info.AddValue("i", n1);

info.AddValue("j", n2);

info.AddValue("k", str);

在序列化过程中调用GetObjectData 时，需要填充方法调用中提供的 SerializationInfo 对象。只需按名称/值对的形式添加将要序列化的变量。其名称可以是任何文本。只要已序列化的数据足以在反序列化过程中还原对象，便可以自由选择添加至 SerializationInfo 的成员变量。如果基对象实现了ISerializable，则派生类应调用其基对象的 GetObjectData 方法。  
  
  需要强调的是，将 ISerializable 添加至某个类时，需要同时实现 GetObjectData 以及特殊的具有特定原型的构造函数－－重要的是，该构造函数的参数列表必须与GetObjectData相同，这个构造函数将会在反序列化的过程中使用： 格式化器从流中反序列化数据，然后通过这个构造函数对对象进行实列化。如果缺少 GetObjectData，编译器将发出警告。但是，由于无法强制实现构造函数，所以，缺少构造函数时不会发出警告。如果在没有构造函数的情况下尝试反序列化某个类，将会出现异常。在消除潜在[安全][Link 2]性和版本控制问题等方面，当前设计优于 SetObjectData 方法。例如，如果将 SetObjectData 方法定义为某个接口的一部分，则此方法必须是公共方法，这使得用户不得不编写代码来防止多次调用 SetObjectData 方法。可以想象，如果某个对象正在执行某些操作，而某个恶意应用程序却调用此对象的 SetObjectData 方法，将会引起一些潜在的麻烦。  
  
  在反序列化过程中，使用出于此目的而提供的构造函数将 SerializationInfo 传递给类。对象反序列化时，对构造函数的任何可见性约束都将被忽略，因此，可以将类标记为 public、protected、internal或 private。一个不错的办法是，在类未封装的情况下，将构造函数标记为 protect。如果类已封装，则应标记为 private。要还原对象的状态，只需使用序列化时采用的名称，从 SerializationInfo 中检索变量的值。如果基类实现了ISerializable，则应调用基类的构造函数，以使基础对象可以还原其变量。  
  
  如果从实现了 ISerializable 的类派生出一个新的类，则只要新的类中含有任何需要序列化的变量，就必须同时实现构造函数以及 GetObjectData 方法。以下代码片段显示了如何使用上文所示的MyObject 类来完成此操作。

\[Serializable\]

public class ObjectTwo : MyObject

public int num;

public ObjectTwo() :  base()\{  \}

protected ObjectTwo(SerializationInfo si, StreamingContextcontext) : base(si,context)

num = si.GetInt32("num");

public override void GetObjectData(SerializationInfo si,StreamingContext context)

base.GetObjectData(si,context);

si.AddValue("num", num);

切记要在反序列化构造函数中调用基类，否则，将永远不会调用基类上的构造函数，并且在反序列化后也无法构建完整的对象。  
  
  对象被彻底重新构建，但是在反系列化过程中调用方法可能会带来不良的副作用,因为被调用的方法可能引用了在调用时尚未反序列化的对象引用。如果正在进行反序列化的类实现了 IDeserializationCallback，则反序列化整个对象图表后，将自动调用 OnSerialization 方法。此时，引用的所有子对象均已完全还原。有些类不使用上述事件侦听器，很难对它们进行反序列化，散列表便是一个典型的例子。在反序列化过程中检索关键字/值对非常容易，但是，由于无法保证从散列表派生出的类已反序列化，所以把这些对象添加回散列表时会出现一些问题。因此，建议目前不要在散列表上调用方法。

序列化又称串行化，是.NET运行时环境用来支持用户定义类型的流化的机制。其目的是以某种存储形成使自定义对象持久化，或者将这种对象从一个地方传输到另一个地方。  
    .NET框架提供了两种串行化的方式：1、是使用BinaryFormatter进行串行化；2、使用SoapFormatter进行串行 化；3、使用XmlSerializer进行串行化。第一种方式提供了一个简单的二进制数据流以及某些附加的类型信息，而第二种将数据流格式化为XML存 储；第三种其实和第二种差不多也是XML的格式存储，只不过比第二种的XML格式要简化很多(去掉了SOAP特有的额外信息)。  
    可以使用\[Serializable\]属性将类标志为可序列化的。如果某个类的元素不想被序列化，1、2可以使用\[NonSerialized\]属性来标志，2、可以使用\[XmlIgnore\]来标志。  
    **1、使用BinaryFormatter进行串行化**  
    下面是一个可串行化的类：

下面是串行化和反串行化的方法：

public void SerializeNow()  
    \{  
        ClassToSerialize c = new ClassToSerialize();  
        FileStream fileStream = new FileStream("c:\\\\temp.dat", FileMode.Create);  
        BinaryFormatter b = new BinaryFormatter();  
        b.Serialize(fileStream, c);  
        fileStream.Close();  
    \}  
    public void DeSerializeNow()  
    \{  
        ClassToSerialize c = new ClassToSerialize();  
        c.Sex = "kkkk";  
        FileStream fileStream = new FileStream("c:\\\\temp.dat", FileMode.Open, FileAccess.Read, FileShare.Read);  
        BinaryFormatter b = new BinaryFormatter();  
        c = b.Deserialize(fileStream) as ClassToSerialize;  
          Response.Write(c.name);  
        Response.Write(c.Sex);  
        fileStream.Close();  
    \}

调用上述两个方法就可以看到串行化的结果：Sex属性因为被标志为\[NonSerialized\],故其值总是为null。  
    **2、使用SoapFormatter进行串行化**  
    和BinaryFormatter类似，我们只需要做一下简单修改即可：  
    a.将using语句中的.Formatter.Binary改为.Formatter.Soap;  
    b.将所有的BinaryFormatter替换为SoapFormatter.  
    c.确保报存文件的扩展名为.xml  
    经过上面简单改动，即可实现SoapFormatter的串行化，这时候产生的文件就是一个xml格式的文件。  
    **3、使用XmlSerializer进行串行化**  
    关于格式化器还有一个问题，假设我们需要XML，但是不想要SOAP特有的额外信息，那么我们应该怎么办呢？有两中方案：要么编写一个实现IFormatter接口的类，采用的方式类似于SoapFormatter类,但是没有你不需要的信息；要么使用库类XmlSerializer，这个 类不使用Serializable属性，但是它提供了类似的功能。  
    如果我们不想使用主流的串行化机制，而想使用XmlSeralizer进行串行化我们需要做一下修改：  
    a.添加System.Xml.Serialization命名空间。  
    b.Serializable和NoSerialized属性将被忽略,而是使用XmlIgnore属性，它的行为与NoSerialized类似。  
    c.XmlSeralizer要求类有个默认的构造器，这个条件可能已经满足了。  
    下面看示例：  
    要序列化的类：

using System;  
using System.Data;  
using System.Configuration;  
using System.Web;  
using System.Web.Security;  
using System.Web.UI;  
using System.Web.UI.WebControls;  
using System.Web.UI.WebControls.WebParts;  
using System.Web.UI.HtmlControls;  
**using System.Xml.Serialization;**  
\[Serializable\]  
public class Person  
\{  
    private string name;  
    public string Name  
    \{  
        get  
        \{  
            return name;  
        \}  
        set  
        \{  
            name = value;  
        \}  
    \}  
  
  
    public string Sex;  
    public int Age = 31;  
    public Course\[\] Courses;  
  
    public Person()  
    \{  
    \}  
    public Person(string Name)  
    \{  
        name = Name;  
        Sex = "男";  
    \}  
\}  
\[Serializable\]  
public class Course  
\{  
    public string Name;  
    \[XmlIgnore\]  
    public string Description;  
    public Course()  
    \{  
    \}  
    public Course(string name, string description)  
    \{  
        Name = name;  
        Description = description;  
    \}  
\}

序列化和反序列化方法：

public void XMLSerialize()  
    \{  
        Person c = new Person("cyj");  
        c.Courses = new Course\[2\];  
        c.Courses\[0\] = new Course("英语", "交流工具");  
        c.Courses\[1\] = new Course("数学","自然科学");  
        XmlSerializer xs = new XmlSerializer(typeof(Person));  
        Stream stream = new FileStream("c:\\\\cyj.XML",FileMode.Create,FileAccess.Write,FileShare.Read);  
        xs.Serialize(stream,c);  
        stream.Close();  
    \}  
    public void XMLDeserialize()  
    \{  
        XmlSerializer xs = new XmlSerializer(typeof(Person));  
        Stream stream = new FileStream("C:\\\\cyj.XML",FileMode.Open,FileAccess.Read,FileShare.Read);  
        Person p = xs.Deserialize(stream) as Person;  
        Response.Write(p.Name);  
        Response.Write(p.Age.ToString());  
        Response.Write(p.Courses\[0\].Name);  
        Response.Write(p.Courses\[0\].Description);  
        Response.Write(p.Courses\[1\].Name);  
        Response.Write(p.Courses\[1\].Description);  
        stream.Close();  
    \}

这里Course类的Description属性值将始终为null，生成的xml文档中也没有该节点，如下图：

<?xml version="1.0"?>  
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">  
  <Sex>男</Sex>  
  <Age>31</Age>  
  <Courses>  
    <Course>  
      <Name>英语</Name>  
      <Description>交流工具</Description>  
    </Course>  
    <Course>  
      <Name>数学</Name>  
      <Description>自然科学</Description>  
    </Course>  
  </Courses>  
  <Name>cyj</Name>  
</Person>

**4、自定义序列化**  
    如果你希望让用户对类进行串行化，但是对数据流的组织方式不完全满意，那么可以通过在自定义类中实现接口来自定义串行化行为。 这个接口只有一个方法，GetObjectData. 这个方法用于将对类对象进行串行化所需要的数据填进SerializationInfo对象。你使用的格式化器将构造SerializationInfo 对象，然后在串行化时调用GetObjectData.如果类的父类也实现了ISerializable，那么应该调用GetObjectData的父类实现。  
    如果你实现了ISerializable，那么还必须提供一个具有特定原型的构造器，这个构造器的参数列表必须与GetObjectData相同。这个构造器应该被声明为私有的或受保护的，以防止粗心的开发人员直接使用它。  
    示例如下：  
    实现ISerializable的类：

using System;  
using System.Data;  
using System.Configuration;  
using System.Web;  
using System.Web.Security;  
using System.Web.UI;  
using System.Web.UI.WebControls;  
using System.Web.UI.WebControls.WebParts;  
using System.Web.UI.HtmlControls;  
using System.Runtime.Serialization;  
using System.Runtime.Serialization.Formatters.Binary;  
/// <summary>  
/// Employee 的摘要说明  
/// </summary>  
\[Serializable\]  
public class Employee:ISerializable  
\{  
    public int EmpId=100;  
    public string EmpName="刘德华";  
    \[NonSerialized\]  
    public string NoSerialString = "NoSerialString-Test";  
    public Employee()  
    \{  
        //  
        // TODO: 在此处添加构造函数逻辑  
        //  
    \}  
    private Employee(SerializationInfo info, StreamingContext ctxt)  
    \{  
        EmpId = (int)info.GetValue("EmployeeId", typeof(int));  
        EmpName = (String)info.GetValue("EmployeeName",typeof(string));  
        //NoSerialString = (String)info.GetValue("EmployeeString",typeof(string));  
    \}  
    public void GetObjectData(SerializationInfo info, StreamingContext ctxt)  
    \{  
        info.AddValue("EmployeeId", EmpId);  
        info.AddValue("EmployeeName", EmpName);  
        //info.AddValue("EmployeeString", NoSerialString);  
    \}  
\}

序列化和反序列化方法：

public void OtherEmployeeClassTest()  
    \{  
        Employee mp = new Employee();  
        mp.EmpId = 10;  
        mp.EmpName = "邱枫";  
        mp.NoSerialString = "你好呀";  
        Stream steam = File.Open("c:\\\\temp3.dat", FileMode.Create);  
        BinaryFormatter bf = new BinaryFormatter();  
        Response.Write("Writing Employee Info:");  
        bf.Serialize(steam,mp);  
        steam.Close();  
        mp = null;  
        //反序列化  
        Stream steam2 = File.Open("c:\\\\temp3.dat", FileMode.Open);  
        BinaryFormatter bf2 = new BinaryFormatter();  
        Response.Write("Reading Employee Info:");  
        Employee mp2 = (Employee)bf2.Deserialize(steam2);  
        steam2.Close();  
        Response.Write(mp2.EmpId);  
        Response.Write(mp2.EmpName);  
        Response.Write(mp2.NoSerialString);  
    \}

[Link 1]: http://storage.it168.com/
[Link 2]: http://safe.it168.com/