c#序列化与反序列化

定义：序列化又称串行化，是.NET运行时环境用来支持用户定义类型的流化的机制。其目的是以某种存储形成使自定义对象持久化，或者将这种对象从一个地方传输到另一个地方。 

通俗解释：程序员在编写应用程序的时候往往要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为"序列化"（Serialization），而它的逆过程则可被称为"反序列化"（Deserialization）。

1. 对象序列化的介绍...................................................................2
(1) .NET支持对象序列化的几种方式.......................................................2
(2) 几种序列化的区别..................................................................2
(3) 使用特性对序列化的控制.............................................................2

2. 使用二进制序列化和反序列化..........................................................2
(1) 二进制序列化与反序列化的程序示例....................................................2
(2) 总结...........................................................................3

3. 使用SOAP方式序列化和反序列化........................................................3
(1) SOAP序列化与反序列化的程序示例.....................................................3
(2) 总结............................................................................4

4. 使用XML方式序列化和反序列化.........................................................4
(1) XML序列化与反序列化的程序示例......................................................4
(2) 总结............................................................................5

5. XML序列化对象详解..................................................................5
(1) 说明.............................................................................5
(2) 使用XmlElement(默认值)............................................................5
(3) 使用XmlAttribute.................................................................5
(4) 使用XmlText......................................................................6
(5) 使用XmlType和XmlAttribute(重命名节点名称).. 6
(6) 列表和数组的序列化.................................................................6
(7) 列表和数组的做为数据成员的序列化......................................................7
(8) 类型继承与反序列化.................................................................9
(9) 排除不需要序列化的成员..............................................................10
(10) 强制指定成员的序列化顺序...........................................................10
(11) 自定义序列化行为..................................................................11
(12) 序列化设置XML命名空间..............................................................11
(13) XML的使用建议.....................................................................11
(14) 反序列化的使用总结.................................................................12

6. 自定义序列化(仅适用于二进制与SOAP).....................................................12
(1) 自定义序列化的实现方式...............................................................12
(2) 示例程序...........................................................................12

1.对象序列化的介绍

(1).NET支持对象序列化的几种方式

二进制序列化：对象序列化之后是二进制形式的，通过BinaryFormatter类来实现的，这个类位于System.Runtime.Serialization.Formatters.Binary命名空间下。

SOAP序列化：对象序列化之后的结果符合SOAP协议，也就是可以通过SOAP 协议传输，通过System.Runtime.Serialization.Formatters.Soap命名空间下的SoapFormatter类来实现的。

XML序列化：对象序列化之后的结果是XML形式的，通过XmlSerializer 类来实现的，这个类位于System.Xml.Serialization命名空间下。XML序列化不能序列化私有数据。

(2)几种序列化的区别

二进制格式和SOAP格式可序列化一个类型的所有可序列化字段，不管它是公共字段还是私有字段。XML格式仅能序列化公共字段或拥有公共属性的私有字段，未通过属性公开的私有字段将被忽略。

使用二进制格式序列化时，它不仅是将对象的字段数据进行持久化，也持久化每个类型的完全限定名称和定义程序集的完整名称（包括包称、版本、公钥标记、区域性），这些数据使得在进行二进制格式反序列化时亦会进行类型检查。SOAP格式序列化通过使用XML命名空间来持久化原始程序集信息。而XML格式序列化不会保存完整的类型名称或程序集信息。这便利XML数据表现形式更有终端开放性。如果希望尽可能延伸持久化对象图的使用范围时，SOAP格式和XML格式是理想选择。

(3)使用特性对序列化的控制

要让一个对象支持.Net序列化服务，用户必须为每一个关联的类加上[Serializable]特性。如果类中有些成员不适合参与序列化（比如：密码字段），可以在这些域前加上[NonSerialized]特性。

2.使用二进制序列化和反序列化

(1)二进制序列化与反序列化的程序示例

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace ConsoleApplication1
{
    [Serializable]  //必须添加序列化特性
    public class Person
    {
        private string Name;//姓名
        private bool Sex;//性别，是否是男

        public Person(string name, bool sex)
        {
            this.Name = name;
            this.Sex = sex;
        }

        public override string ToString()
        {
            return "姓名：" + this.Name + "	性别：" + (this.Sex ? "男" : "女");
        }
    }

    [Serializable]  //必须添加序列化特性
    public class Programmer : Person
    {
        private string Language;//编程语言

        public Programmer(string name, bool sex, string language)
            : base(name, sex)
        {
            this.Language = language;
        }

        public override string ToString()
        {
            return base.ToString() + "	编程语言：" + this.Language;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //创建Programmer列表，并添加对象
            List<Programmer> list = new List<Programmer>();
            list.Add(new Programmer("张三", true, "C#"));
            list.Add(new Programmer("Coder2", false, "C++"));
            list.Add(new Programmer("Coder3", true, "Java"));

            //使用二进制序列化对象
            string fileName = @"F:	est.dat";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite);
            BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
            binFormat.Serialize(fStream, list);

            //使用二进制反序列化对象
            list.Clear();//清空列表
            fStream.Position = 0;//重置流位置
            list = (List<Programmer>)binFormat.Deserialize(fStream);//反序列化对象

            foreach (Programmer p in list)
            {
                Console.WriteLine(p);
            }

            Console.Read();
        }
    }
}

首先要在解决方案中添加对System.Runtime.Serialization.Formatters.Soap的引用，直接写using System.Runtime.Serialization.Formatters.Soap;不行

 

(2)总结

使用二进制序列化，必须为每一个要序列化的的类和其关联的类加上[Serializable]特性，对类中不需要序列化的成员可以使用[NonSerialized]特性。

二进制序列化对象时，能序列化类的所有成员(包括私有的)，且不需要类有无参数的构造方法。

使用二进制格式序列化时，它不仅是将对象的字段数据进行持久化，也持久化每个类型的完全限定名称和定义程序集的完整名称（包括包称、版本、公钥标记、区域性），这些数据使得在进行二进制格式反序列化时亦会进行类型检查。所以反序列化时的运行环境要与序列化时的运行环境要相同，否者可能会无法反序列化成功。

 

3.使用SOAP方式序列化和反序列化

(1)SOAP序列化与反序列化的程序示例

  static void Main(string[] args)
        {
            //实例化对象
            Programmer p = new Programmer("张三", true, "C#、C++、Python");

            //使用SOAP序列化对象
            string fileName = @"D:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite);
            SoapFormatter soapFormat = new SoapFormatter();//创建SOAP序列化器
            soapFormat.Serialize(fStream, p);//SOAP不能序列化泛型对象

            //使用SOAP反序列化对象
            fStream.Position = 0;//重置流位置
            p = null;
            p = (Programmer)soapFormat.Deserialize(fStream);
            Console.WriteLine(p);
            Console.Read();
        }

(2)总结

SOAP序列化与二进制序列化的区别是：SOAP序列化不能序列化泛型类型。与二进制序列化一样在序列化时不需要向序列化器指定序列化对象的类型。而XML序列化需要向XML序列化器指定序列化对象的类型。

 

4.使用XML方式序列化和反序列化

(1)XML序列化与反序列化的程序示例

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    [Serializable]  //必须添加序列化特性

    public class Person
    {
        public string Name;//姓名
        public bool Sex;//性别，是否是男

        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错

        public Person(string name, bool sex)
        {
            this.Name = name;
            this.Sex = sex;
        }

        public override string ToString()
        {
            return "姓名：" + this.Name + "	性别：" + (this.Sex ? "男" : "女");
        }
    }

    [Serializable]  //必须添加序列化特性
    public class Programmer : Person
    {
        public string Language;//编程语言
        public Programmer() { }//必须提供无参构造器，否则XmlSerializer将出错

        public Programmer(string name, bool sex, string language)
            : base(name, sex)
        {
            this.Language = language;
        }

        public override string ToString()
        {
            return base.ToString() + "	编程语言：" + this.Language;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //创建Programmer列表，并添加对象
            List<Programmer> list = new List<Programmer>();
            list.Add(new Programmer("张三", true, "C#"));
            list.Add(new Programmer("Coder2", false, "C++"));
            list.Add(new Programmer("Coder3", true, "Python"));

            //使用XML序列化对象
            string fileName = @"F:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite);
            //创建XML序列化器，需要指定对象的类型
            XmlSerializer xmlFormat = new XmlSerializer(typeof(List<Programmer>), new Type[] { typeof(Programmer), typeof(Person) });
            xmlFormat.Serialize(fStream, list);

            //使用XML反序列化对象
            fStream.Position = 0;//重置流位置
            list.Clear();
            list = (List<Programmer>)xmlFormat.Deserialize(fStream);
            foreach (Programmer p in list)
            {
                Console.WriteLine(p);
            }
            Console.Read();
        }
    }
}

(2)总结

使用XML序列化或反序列化时，需要对XML序列化器指定需要序列化对象的类型和其关联的类型。

XML序列化只能序列化对象的公有属性，并且要求对象有一个无参的构造方法，否者无法反序列化。

[Serializable]和[NonSerialized]特性对XML序列化无效！所以使用XML序列化时不需要对对象增加[Serializable]特性。

5.XML序列化对象详解

(1)说明

本节主要介绍：使用特性控制对象序列化成XML文件的格式。

(2)使用XmlElement(默认值)

类声明：

    [Serializable]
    public class Person
    {
        [XmlElement]
        public string Name;  //使用[XmlElement]特性
        public bool Sex;     //默认使用了[XmlElement]特性
        public Person() { }  //必须提供无参构造器，否则XmlSerializer将出错
    }

序列化生成的XML文件：

  <Programmer>
    <Name>张三</Name>
    <Sex>true</Sex>
  </Programmer>

(3)使用XmlAttribute

类声明：

    [Serializable]
    public class Person
    {
        [XmlElement]
        public string Name;  //使用[XmlElement]特性
        [XmlAttribute]
        public bool Sex;     
        public Person() { }  //必须提供无参构造器，否则XmlSerializer将出错
    }

序列化生成的XML文件：

  <Programmer Sex="true">
    <Name>张三</Name>
  </Programmer>

(4)使用XmlText

类声明：

    [Serializable]
    public class Person
    {
        [XmlText]
        public string Name;
        [XmlAttribute]
        public bool Sex; 
    }

序列化生成的XML文件：

  <Programmer Sex="true">张三</Programmer>

(5)使用XmlType和XmlAttribute(重命名节点名称)

类声明：

    [XmlType("个人信息")]
    public class Person
    {
        [XmlAttribute("姓名")]
        public string Name;
        [XmlAttribute("性别")]
        public bool Sex;     

序列化生成的XML文件：

<个人信息 姓名="张三" 性别="true" />

(6)列表和数组的序列化

类声明：

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    [XmlType("个人信息")]

    public class Person
    {
        [XmlAttribute("姓名")]
        public string Name;
        [XmlAttribute("性别")]
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person();
            p.Name = "张三";
            p.Sex = true;
            Person[] ps = new Person[3];
            ps[0] = p;
            ps[1] = p;
            ps[2] = p;

            //使用XML序列化对象
            string fileName = @"F:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create);
            XmlSerializer xmlFormat = new XmlSerializer(typeof(Person[]));
            xmlFormat.Serialize(fStream, ps);//序列化对象
            fStream.Dispose();//关闭文件
            Console.WriteLine("OK!");
            Console.Read();
        }
    }
}

序列化生成的XML文件：

<?xml version="1.0"?>
<ArrayOf个人信息 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <个人信息 姓名="张三" 性别="true" />
  <个人信息 姓名="张三" 性别="true" />
  <个人信息 姓名="张三" 性别="true" />
</ArrayOf个人信息>

注意：发现此时的XML文件的根节点名称变了（<ArrayOf个人信息）。此时要重命名根节点应使用如下方式：

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    [XmlType("个人信息")]
    public class Person
    {
        [XmlAttribute("姓名")]
        public string Name;
        [XmlAttribute("性别")]
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

    [XmlType("人员信息")]
    public class PersonArray : List<Person> { }

    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person();
            p.Name = "张三";
            p.Sex = true;
            PersonArray ps = new PersonArray();
            ps.Add(p);
            ps.Add(p);
            ps.Add(p);

            //使用XML序列化对象
            string fileName = @"F:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create);
            XmlSerializer xmlFormat = new XmlSerializer(typeof(PersonArray));
            xmlFormat.Serialize(fStream, ps);//序列化对象
            fStream.Dispose();//关闭文件
            Console.WriteLine("OK!");
            Console.Read();
        }
    }
}

序列化生成的XML文件：

<人员信息 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <个人信息 姓名="张三" 性别="true" />
  <个人信息 姓名="张三" 性别="true" />
  <个人信息 姓名="张三" 性别="true" />
</人员信息>

(7)列表和数组的做为数据成员的序列化

类声明：

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    [XmlType("个人信息")]
    public class Person
    {
        [XmlAttribute("姓名")]
        public string Name;
        [XmlAttribute("性别")]
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

    [XmlType("人员信息")]
    public class PersonArray
    {
        public List<Person> Array = new List<Person>();
        public Person Person = new Person();
    }

    class Program
    {
        static void Main(string[] args)
        {         
            PersonArray ps = new PersonArray();
            ps.Person = new Person();
            ps.Person.Name = "张三";
            ps.Person.Sex = true;
            ps.Array.Add(ps.Person);
            ps.Array.Add(ps.Person);
            ps.Array.Add(ps.Person);

            //使用XML序列化对象
            string fileName = @"F:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create);
            XmlSerializer xmlFormat = new XmlSerializer(typeof(PersonArray));
            xmlFormat.Serialize(fStream, ps);//序列化对象
            fStream.Dispose();//关闭文件
            Console.WriteLine("OK!");
            Console.Read();
        }
    }
}

序列化生成的XML文件：

<?xml version="1.0"?>
<人员信息 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Array>
    <个人信息 姓名="张三" 性别="true" />
    <个人信息 姓名="张三" 性别="true" />
    <个人信息 姓名="张三" 性别="true" />
  </Array>
  <Person 姓名="张三" 性别="true" />
</人员信息>

注意：假设这里需要为Array和Person的节点重命名，代码如下：

    [XmlType("人员信息")]
    public class PersonArray
    {
        [XmlArrayItem("信息项")]
        [XmlArray("信息组")]
        public List<Person> Array = new List<Person>();
        public Person Person = new Person();
    }

序列化生成的XML文件：

<?xml version="1.0"?>
<人员信息 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <信息组>
    <信息项 姓名="张三" 性别="true" />
    <信息项 姓名="张三" 性别="true" />
    <信息项 姓名="张三" 性别="true" />
  </信息组>
  <Person 姓名="张三" 性别="true" />
</人员信息>

注意：把“信息组”节点去掉呢(直接出现“信息项”节点)

    [XmlType("个人信息")]
    public class Person
    {
        [XmlAttribute("姓名")]
        public string Name;
        [XmlAttribute("性别")]
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

    [XmlType("人员信息")]
    public class PersonArray
    {
        [XmlElement("信息项")]
        public List<Person> Array = new List<Person>();
        public Person Person = new Person();
    }

序列化生成的XML文件：

<?xml version="1.0"?>
<人员信息 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <信息项 姓名="张三" 性别="true" />
  <信息项 姓名="张三" 性别="true" />
  <信息项 姓名="张三" 性别="true" />
  <Person 姓名="张三" 性别="true" />
</人员信息>

(8)类型继承与反序列化

类声明：

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    public class Base { }

    [XmlType("信息A")]
    public class PersonA : Base
    {
        [XmlAttribute("姓名")]
        public string Name;
        [XmlAttribute("性别")]
        public bool Sex;
        public PersonA() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

    [XmlType("信息B")]
    public class PersonB : Base
    {
        [XmlElement("姓名")]
        public string Name;
        [XmlElement("年龄")]
        public int Age;
        public PersonB() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

    [XmlType("人员信息")]
    public class PersonArray
    {
        [XmlArrayItem(typeof(PersonA)), XmlArrayItem(typeof(PersonB))]
        public List<Base> ListPerson = new List<Base>();
    }

    class Program
    {
        static void Main(string[] args)
        {
            PersonA pa = new PersonA();
            pa.Name = "张三";
            pa.Sex = true;

            PersonB pb = new PersonB();
            pb.Name = "李四";
            pb.Age = 21;

            PersonArray ps = new PersonArray();
            ps.ListPerson.Add(pa);
            ps.ListPerson.Add(pa);
            ps.ListPerson.Add(pb);
            ps.ListPerson.Add(pb);

            //使用XML序列化对象
            string fileName = @"F:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create);
            XmlSerializer xmlFormat = new XmlSerializer(typeof(PersonArray));
            xmlFormat.Serialize(fStream, ps);//序列化对象
            fStream.Dispose();//关闭文件
            Console.WriteLine("OK!");
            Console.Read();
        }
    }
}

序列化生成的XML文件：

<?xml version="1.0"?>
<人员信息 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <ListPerson>
    <信息A 姓名="张三" 性别="true" />
    <信息A 姓名="张三" 性别="true" />
    <信息B>
      <姓名>李四</姓名>
      <年龄>21</年龄>
    </信息B>
    <信息B>
      <姓名>李四</姓名>
      <年龄>21</年龄>
    </信息B>
  </ListPerson>
</人员信息>

注意：同时为列表成员指定多个[XmlArrayItem(typeof(XXX))]可实现多种派生类型混在一起输出。

(9)排除不需要序列化的成员

类声明：

    public class Person
    {      
        public string Name;
        [XmlIgnore]// 这个属性将不会参与序列化
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

序列化生成的XML文件：

<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>张三</Name>
</Person>

(10)强制指定成员的序列化顺序

类声明：

  public class Person
    {
        [XmlElement(Order = 2)]
        public string Name;
        [XmlElement(Order = 1)]
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

序列化生成的XML文件：

<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Sex>true</Sex>
  <Name>张三</Name>
</Person>

(11)自定义序列化行为

类声明：

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    public class Person : IXmlSerializable
    {      
        public string Name;    
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错

        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }

        public void ReadXml(System.Xml.XmlReader reader)
        {
            Name = reader.GetAttribute("姓名");
            Sex = reader.GetAttribute("性别").Equals("男") ? true : false;
        }

        public void WriteXml(System.Xml.XmlWriter writer)
        {
            writer.WriteAttributeString("姓名", Name);
            writer.WriteAttributeString("性别", Sex ? "男" : "女");
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person();
            p.Name = "张三";
            p.Sex = true;

            //使用XML序列化对象
            string fileName = @"F:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create);
            XmlSerializer xmlFormat = new XmlSerializer(typeof(Person));
            xmlFormat.Serialize(fStream, p);//序列化对象
            fStream.Dispose();//关闭文件
            Console.WriteLine("OK!");
            Console.Read();
        }
    }
}

序列化生成的XML文件：

<?xml version="1.0"?>
<Person 姓名="张三" 性别="男" />

 

(12)序列化设置XML命名空间

类声明：

    [XmlRoot(Namespace = "http://msdn.microsoft.com/vsdh.xsd")]
    public class Person
    {      
        public string Name;    
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错
    }

序列化生成的XML文件：

<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://msdn.microsoft.com/vsdh.xsd">
  <Name>张三</Name>
  <Sex>true</Sex>
</Person>

(13)XML的使用建议

在服务端，C#代码中：

1. 建议不用使用低级别的XML API来使用XML，除非你是在设计框架或者通用类库。

2. 建议使用序列化、反序列化的方法来生成或者读取XML

3. 当需要考虑使用XML时，先不要想着XML结构，先应该定义好数据类型。

4. 列表节点不要使用[XmlElement]，它会让所有子节点【升级】，显得结构混乱。

5. 如果希望序列化的XML长度小一点，可以采用[XmlAttribute]，或者指定一个更短小的别名。

6. 不要在一个列表中输出不同的数据类型，这样的XML结构的可读性不好。

7. 尽量使用UTF-8编码，不要使用GB2312编码。

在客户端，JavaScript代码中，我不建议使用XML，而是建议使用JSON来代替XML，因为：

1. XML文本的长度比JSON要长，会占用更多的网络传输时间(毕竟数据保存在服务端，所以传输是免不了的)。

2. 在JavaScritp中使用XML比较麻烦(还有浏览器的兼容问题),反而各种浏览器对JSON有非常好的支持。

(14)反序列化的使用总结

如果XML是由类型序列化得到那的，那么反序列化的调用代码是很简单的，反之，如果要面对一个没有类型的XML，就需要我们先设计一个(或者一些)类型出来，这是一个逆向推导的过程，请参考以下步骤：

1. 首先要分析整个XML结构，定义与之匹配的类型，

2. 如果XML结构有嵌套层次，则需要定义多个类型与之匹配，

3. 定义具体类型（一个层级下的XML结构）时，请参考以下表格。

XML形式	处理方法	补充说明
XmlElement	定义一个属性	属性名与节点名字匹配
XmlAttribute	[XmlAttribute] 加到属性上
InnerText	[InnerText] 加到属性上	一个类型只能使用一次
节点重命名	根节点：[XmlType("testClass")]  元素节点：[XmlElement("name")]  属性节点：[XmlAttribute("id")]  列表子元素节点：[XmlArrayItem("Detail")]  列表元素自身：[XmlArray("Items")]

6.自定义序列化(仅适用于二进制与SOAP)

(1)自定义序列化的实现方式

可以通过在对象上实现 ISerializable 接口来自定义序列化过程。这一功能在反序列化后成员变量的值失效时尤其有用，但是需要为变量提供值以重建对象的完整状态。要实现ISerializable，需要实现 GetObjectData()方法以及一个特殊的构造函数，在反序列化对象时要用到此构造函数。

(2)示例程序

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace ConsoleApplication1
{
  [Serializable]
    public class Person
    {      
        public string Name;    
        public bool Sex;
        public Person() { }//必须提供无参构造器，否则XmlSerializer将出错

        //必须的构造方法,反序列化时调用

        protected Person(SerializationInfo info, StreamingContext context)
        {
            Name = info.GetString("姓名");
            Sex = info.GetBoolean("性别");
        }

        //序列化时调用
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("姓名", Name + "(自定义序列化)");
            info.AddValue("性别", Sex);
        }

        public override string ToString()
        {
            return "姓名：" + this.Name + "	性别：" + (this.Sex ? "男" : "女");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person();
            p.Name = "张三";
            p.Sex = true;

            //使用二进制序列化对象
            string fileName = @"F:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create);
            BinaryFormatter binFormat = new BinaryFormatter();
            binFormat.Serialize(fStream, p);//序列化对象

            //使用二进制反序列化对象
            fStream.Position = 0;//重置流位置
            p = (Person)binFormat.Deserialize(fStream);//反序列化对象
            Console.WriteLine(p);
            fStream.Dispose();//关闭文件
            Console.WriteLine("OK!");
            Console.Read();
        }
    }
}

注意：在序列化过程中调用 GetObjectData()时，需要填充方法调用中提供的SerializationInfo对象。只需按名称/值对的形式添加将要序列化的变量。其名称可以是任何文本。只要已序列化的数据足以在反序列化过程中还原对象，便可以自由选择添加至SerializationInfo 的成员变量。如果基对象实现了 ISerializable，则派生类应调用其基对象的 GetObjectData()方法。同样，在反序列化时也会调用含有(SerializationInfo info, StreamingContextcontext)参数的特殊的够着方法！否者将无法反序列化！！！

7.序列化xml，在root根节点添加属性

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    [Serializable]
    [XmlType("root")]
    public class Root
    {
        public Root() { }

        [XmlAttribute]
        public string id = "";

        [XmlAttribute]
        public string style = "";

        [XmlElement("node")]  //加上XmlElement能去掉listNode节点
        public List<Node> listNode = new List<Node>();
    }

    [Serializable]
    public class Node
    {
        public Node() { }
        public Node(string name)
        {
            this.Name = name;
        }

        [XmlAttribute]
        public string Name;
        [XmlAttribute]
        public string Sex = "男";
    }

    class Program
    {
        static void Main(string[] args)
        {
            Root root = new Root();
            root.listNode.Add(new Node("张三"));
            root.listNode.Add(new Node("李四"));

            //使用XML序列化对象
            string fileName = @"F:	est.xml";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create);
            XmlSerializer xmlFormat = new XmlSerializer(typeof(Root));

            XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
            ns.Add("", "");  //去掉根节点内的名称空间

            xmlFormat.Serialize(fStream, root, ns);//序列化对象
            fStream.Dispose();//关闭文件
            Console.WriteLine("OK!");
            Console.Read();
        }
    }
}

序列化生成的XML文件：

<?xml version="1.0"?>
<root id="" style="">
  <node Name="张三" Sex="男" />
  <node Name="李四" Sex="男" />
</root>

引用:

[1]C#对象序列化与反序列化

[2].net序列化及反序列化

后记

其他的序列化JavaScriptSerializer  DataContract  Newtonsoft.Json