.NET中的Serialization

清疚 2022-09-19 05:24 93阅读 0赞

Serialization是.NET中一种实现对象持久性（Persistent）的机制。它是一个将对象中的数据转换成一个单一元素（通常是Stream）的过程。它的逆过程是Deserialization。Serialization的核心概念是将一个对象的所有数据看作一个独立的单元。

一般说来，在两种情况下非常需要Serialization：1）当我们希望能够将对象当前的状态完整地保存到存储介质中，以便我们以后能够精确地还原对象时；2）当我们希望将对象从一个应用程序空间（Application domain）传递到另一个应用程序空间时。例如，Windows Form程序就是利用Serialization机制来实现剪贴板的copy & paste的。   
  
　　.NET Framework支持两种类型的Serialization：Shallow Serialization和Deep Serialization。   
  
　　所谓Shallow Serialization是将对象的可读写（read-write）属性的值转换成字节流，而对象内部的数据（没有通过read-write属性暴露出来的数据）则不被转换。XMLSerializer以及Web Services就使用这种技术。   
  
　　Deep Serialization比Shallow Serialization更加彻底，因为它是将存储在对象私有变量里的实际值拷贝到字节流里。而且Deep Serialization还将serialize整个object graph。也就是说，如果你的对象持有其他对象的引用，或者其他对象引用的集合，那么所有这些对象都将被Serialize。BinaryFormatter和SoapFormatter以及.NET Remoting都使用Deep Serialization技术，它甚至被有限地用于LosFormatter来产生存储在Web Form页中的状态数据。

**一：Deep Serialization的过程**   
  
  
　　.NET Framework通过Reflection提供自动Serialization的机制。当一个对象被序列化（Serialized）的时候，它的类名，Assembly，以及类实例的所有数据成员都将被写入存储介质中。Serialization引擎保持对所有已经被序列化的对象引用的追踪，以确保相同的对象引用最多只被序列化一次。   
  
　　通常，一个Serialization过程会由formatter（例如BinaryFormatter）的Serialize方法引发。对象的Serialization过程按照以下规则进行：   
  
　　1、 检测以确保formatter是否拥有一个代理选择器（surrogate selector）。如果有，检查代理选择器是否持有给定的对象类型。如果有，ISerializable.GetObjectData被调用。   
  
　　2、 如果formatter没有代理选择器，或者代理选择器没有对象类型，检查对象是否被用Serializable属性标记。如果没有，则抛出SerializationException异常。   
  
　　3、 如果对象被标记为Serializable，检查对象是否实现了ISerializable接口。如果实现了此接口，则GetObjectData被调用。   
  
　　4、 如果对象没有实现ISerializable接口，则使用默认的序列化策略，来序列化没有用NonSerialized属性标记的域。

如果某个类的元素不想被序列化，可以使用\[NonSerialized\]属性来标志，

如下：

\[Serializable\]  
public class ClassToSerialize  
\{  
    public int id = 100;  
    public string name = "Name";  
    \[NonSerialized\]  
    public string Sex = "男";  
\}  
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();  
    \}

**二：Shallow Serialization的过程**

其实此序列化的对象不需要［Serializable］来标识。它只是把对象属性以一定的格式来存放，如XML格式，所以序列出来的字符串我们也是可以看懂的。

如果某个类的元素不想被序列化，可以使用\[XmlIgnore\]来标志。

如下：

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 = "男";  
    \}  
\}  
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();  
    \}

序列化字符串

<?xml version="1.0"?>  
<Person xmlns:xsi="[http://www.w3.org/2001/XMLSchema-instance][http_www.w3.org_2001_XMLSchema-instance]" xmlns:xsd="[http://www.w3.org/2001/XMLSchema][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>

**三：自定义序列化**

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

示例如下：  
 实现ISerializable的类：

\[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);  
    \}

[http_www.w3.org_2001_XMLSchema-instance]: http://www.w3.org/2001/XMLSchema-instance
[http_www.w3.org_2001_XMLSchema]: http://www.w3.org/2001/XMLSchema