C#—序列化(Serialize)和反序列化(NonSerialize)

（转自：http://www.cnblogs.com/Abel-Zhang/p/Serialize.html）

一、概述

序列化是把对象转变成流。相反的过程就是反序列化。

哪些场合用到这项技术呢？

1. 把对象保存到本地，下次运行程序时恢复这个对象。

2. 把对象传送到网络的另一台终端上，然后在此终端还原这个对象。

3. 复制系统的粘帖板中，然后用快捷键Ctrl+V恢复这个对象。

常用的序列化流有Binary(二进制流)，XML,SOAP。

二、序列化和反序列化使用事例：

这里我们把序列化和反序列化以功能类的形式展现：

 

 public class Serializer
    {
        //将类型序列化为字符串
        public static string Serialize<T>(T t) where T : class
        { 
            using(MemoryStream stream=new MemoryStream())
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, t);
                return System.Text.Encoding.UTF8.GetString(stream.ToArray());
            }
        }

        //将类型序列化为文件
        public static void SerializeToFile<T>(T t, string path, string fullName) where T : class
        {
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
            string fullPath = string.Format(@"{0}\{1}", path, fullName);
            using (FileStream stream = new FileStream(fullPath,FileMode.OpenOrCreate))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, t);
                stream.Flush();
            }
        }

        //将类型序列化为文件
        public static void SerializeToFileByXml<T>(T t, string path, string fullName) where T : class
        {
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
            
            string fullPath = string.Format(@"{0}\{1}", path, fullName);

            using (FileStream stream = new FileStream(fullPath, FileMode.OpenOrCreate))
            {
                XmlSerializer formatter = new XmlSerializer(typeof(T));
                formatter.Serialize(stream, t);
                stream.Flush();
            }
        }
        //将字符串反序列化为类型
        public static TResult Deserialize<TResult>(string s) where TResult : class
        {
            byte[] bs = System.Text.Encoding.UTF8.GetBytes(s);
            using (MemoryStream stream = new MemoryStream(bs))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                return formatter.Deserialize(stream) as TResult;
            }
        }

        //将文件反序列化为类型
        public static TResult DeserializeFromFile<TResult>(string path) where TResult : class
        {
            using (FileStream stream = new FileStream(path,FileMode.Open))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                return formatter.Deserialize(stream) as TResult;
            }
        }

        //将xml文件反序列化为类型
        public static TResult DeserializeFromFileByXml<TResult>(string path) where TResult : class
        {
            using (FileStream stream = new FileStream(path, FileMode.Open))
            {
                XmlSerializer formatter = new XmlSerializer(typeof(TResult)); ;
                return formatter.Deserialize(stream) as TResult;
            }
        }
    }

上面事例中的方法是以泛型方法实现的，其中附加了泛型约束，保证泛型安全。

序列化功能类有了下面我们建一个Book对象,用它来测试我们的功能类。

    [Serializable]
    public class Book
    {
        [NonSerialized]
        private string _bookPwd;
        [field: NonSerialized]
        public event EventHandler NameChanged;
        private string _bookName;
        private string _bookID;
        public ArrayList alBookReader;
        public string _bookPrice;

        public Book()
        {
            alBookReader = new ArrayList();
        }

        public string BookName
        {
            get { return _bookName; }
            set
            {
                if (NameChanged != null)
                {
                    NameChanged(this, null);
                }
                _bookName = value;
            }
        }

        public void BookPwd(string pwd)
        {
             _bookPwd=pwd;
        }
       
        public string BookID
        {
            get { return _bookID; }
            set { _bookID = value; }
        }

        public void SetBookPrice(string price)
        {
            _bookPrice = price;
        }

        [OnDeserializedAttribute]
        public void changeName(StreamingContext context)
        {
            this.BookName = "C#深入浅出";
        }

        public void Write()
        {
            Console.WriteLine("Book ID:" + BookID);
            Console.WriteLine("Book Name:" + BookName);
            Console.WriteLine("Book Password:" + _bookPwd);
            Console.WriteLine("Book Price:" + _bookPrice);
            Console.WriteLine("Book Reader:");
            for (int i = 0; i < alBookReader.Count; i++)
            {
                Console.WriteLine(alBookReader[i]);
            }
        }
    }

 

关键介绍：
1.[Serializable]特性定义该类型可以被序列化；

2.[NonSerialized]定义某个属性不被序列化，即：内部成员被NonSerialized禁止序列化特性标记；

3.[field: NonSerialized]定义事件不被序列化；

4.[OnDeserializedAttribute]当它应用于某个方法时，会指定对象被反序列化后立即执行此方法。

5.[OnDeserializingAttribute]当它应用于某个方法时，会指定对象被反序列化时立即执行此方法。

6.[OnSerializedAttribute]如果将对象图应用于某个方法时，会指定在序列化该对象图后是否调用此方法。

7.[OnSerializingAttribute]当它应用于某个方法时，会指定在对象序列化前调用此方法。、

我们用控制台程序实现序列化和反序列化：

static void Main(string[] args)
        {
            string path = "c:\\Test\\";
            Book book = new Book();
            book.NameChanged += new EventHandler(make_NameChanged);
            book.BookID = "2001";
            book.alBookReader.Add("Abel");
            book.alBookReader.Add("Tomson");
            book.BookName = "敏捷无敌";
            book.BookPwd("*****");
            book.SetBookPrice("102.00");
            //对象序列化
            Serializer.SerializeToFileByXml<Book>(book, path, "book.txt");
            //对象反序列化
            Book anothorbookserialize = new Book();
            anothorbookserialize = Serializer.DeserializeFromFileByXml<Book>(path + "book.txt");
            anothorbookserialize.Write();
            Console.ReadKey();
        }

        static void make_NameChanged(object sender, EventArgs e)
        {
            Console.WriteLine("Name Changed");
        }

我们的事例是调用XML序列化流文件形式，序列化执行后的文件如下：

<?xml version="1.0"?>
<Book xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <alBookReader>
    <anyType xsi:type="xsd:string">Abel</anyType>
    <anyType xsi:type="xsd:string">Tomson</anyType>
  </alBookReader>
  <_bookPrice>102.00</_bookPrice>
  <BookName>敏捷无敌</BookName>
  <BookID>2001</BookID>
</Book>

反序列化输出如下：

Name Changed
Book ID:2001
Book Name:敏捷无敌
Book Password:
Book Price:102.00
Book Reader:
Abel
Tomson

结果分析：

[NonSerialized]Book Password属性在序列化XML文件中没有出现Book Password。

[field: NonSerialized]NameChanged事件，在序列化XML文件中没有出现NameChanged。

[OnDeserializedAttribute]changeName()方法，执行反序列化后没有立即执行changeName()方法，Book Name名称没有改变，需要通过Binary流形式才能成功执行方法。

    //序列化
    Serializer.SerializeToFile<Book>(book, path, "book.txt");
    //反序列化
    anothorbookserialize = Serializer.DeserializeFromFile<Book>(path + "book.txt");

我们以XML流为例是为了更好的理解序列化和反序列化的执行过程，实际应用中多数以Binary流形式实现序列化和反序列化较多。

三、继承ISerializable接口更灵活的控制序列化过程：

　　当以上Serializable特性无法满足复杂的序列化过程时就需要实现ISerializable接口了。

　　以下是格式化器的工作流程：如果格式化器在序列化一个对象的时候，发现对象实现了ISerializable接口，那他会忽略类所有序列化特性，转而调用GetObjectData方法的一个SerializationInfo对象，方法内部负责该对象属性的添加。反序列化时调用该对象受保护带参数构造方法中的一个SerializationInfo对象，方法内部对象属性赋值。

下面我们实现ISerializable接口的子类型应负责父类型的序列化为例：

1.父类同样实现了ISerializable接口

 

[Serializable]
    public class Person:ISerializable
    {
        public string Name{get;set;}
        
        public Person()
        {

        }

        protected Person(SerializationInfo info,StreamingContext context)
        {
            Name = info.GetString("Name");
        }

        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("Name",Name);
        }
    }
    [Serializable]
    public class Employee: Person , ISerializable
    {
        public int Salary{get;set;}

public Employee()
        {

        }

        protected Employee(SerializationInfo info, StreamingContext context)
        {
            Salary = info.GetInt32("Salary");
            Name = info.GetString("Name");
        }

        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            base.GetObjectData(info,context);
            info.AddValue("Salary", Salary);
        }
    }

注意：Employee中的GetObjectData方法覆盖了基类Person中的虚方法GetObjectData。

 

Employee employee = new Employee() { Name = "Abel", Salary=1220 };
BinarySerializer.SerializeToFile<Employee>(employee, strFile, "employee.txt");
employee = BinarySerializer.DeserializeFromFile<Employee>("c:\\Test\\employee.txt");
Console.WriteLine(employee.Name);
Console.WriteLine(employee.Salary);

2.若父类没有实现了ISerializable接口如何处理呢？

我们要实现继承ISerializable接口的Employee类的一个父类Person，Person没有实现ISerializable接口，序列化器没有默认去处理Person对象，只能由我们自己去做。

下面我们用具体实例实现：

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

    [Serializable]
    public class Employee: Person , ISerializable
    {
        public int Salary{get;set;}

        public Employee()
        {

        }

        protected Employee(SerializationInfo info, StreamingContext context)
        {
            Salary = info.GetInt32("Salary");
            Name = info.GetString("Name");
        }

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("Name", Name);
            info.AddValue("Salary", Salary);
        }
    }

 

在这此序列化学习中我们用到了事件、泛型和流文件的处理知识，通过序列化我们可以实现本地加载，远程还原对象。

得到了一个Serializer工具类，该工具类封装了序列化和反序列化的过程。

 

此外，PageViewBase.JsonDeserializer<Dictionary<string, object>>(str);  可以处理json字串。