C# 用XmlSerializer进行序列化和反序列化

和BinaryFormatter序列化一样，做一个可以序列化的类Person：

namespace Serializable
{
    [Serializable] //不可少！ 
    public class Person
    {
        private String name;
        private String sex;
        private int age;

        public Person() //XmlSerializer序列化要求一定要有无参数构造函数 
        {
            name = "";
            sex = "";
            age = 0;
        }

        public Person(String n, String s, int a)
        {
            name = n;
            sex = s;
            age = a;
        }

        public String Name
        {
            get 
            {
                return name;
            }
            set 
            {
                name = value;
            }
        }

        public String Sex
        {
            get
            {
                return sex;
            }
            set
            {
                sex = value;
            }
        }

        public int Age
        {
            get
            {
                return age;
            }
            set
            {
                age = value;
            }
        }
    }
}

 

//主运行程序

namespace Serializable
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p1 = new Person("张三", "男", 20);
            //序列化
            try
            {
                FileStream fs = new FileStream("serialiable.xml", FileMode.Create);
                XmlSerializer xs = new XmlSerializer(typeof(Person));
                xs.Serialize(fs, p1);
                fs.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.WriteLine("序列化成功！");

            Console.Read();

            //反序列化
            try
            {
                FileStream fs = new FileStream("serialiable.xml", FileMode.Open, FileAccess.Read);
                XmlSerializer xs = new XmlSerializer(typeof(Person));
                Person p = (Person)xs.Deserialize(fs);
                Console.WriteLine(p.Name + p.Sex + p.Age);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }

            Console.Read();
            Console.Read();
        }
    }
}

 

结果图：

 

生成的XML文件：

1. 这篇随笔对应的.Net命名空间是System.Xml.Serialization；文中的示例代码需要引用这个命名空间。
2. 为什么要做序列化和反序列化？
3. .Net程序执行时，对象都驻留在内存中；内存中的对象如果需要传递给其他系统使用；或者在关机时需要保存下来以便下次再次启动程序使用就需要序列化和反序列化。
4. 范围：本文只介绍xml序列化，其实序列化可以是二进制的序列化，也可以是其他格式的序列化。
5. 看一段最简单的Xml序列化代码
6. class Program
7. {
8.      static void Main(string[] args)
9.     {
10.          int i = 10;
11.          //声明Xml序列化对象实例serializer
12.         XmlSerializer serializer = new XmlSerializer( typeof( int));
13.          //执行序列化并将序列化结果输出到控制台
14.         serializer.Serialize(Console.Out, i);
15.         Console.Read();
16.     }
17. }
18. 上面代码对 int i进行了序列化，并将序列化的结果输出到了控制台，输出结果如下
20. <?xml version= "1.0" encoding= "gb2312"?>
21. < int> 10</ int>
22. 可以将上述序列化的xml进行反序列化，如下代码
23. static void Main(string[] args)
24. {
25.      using (StringReader rdr = new StringReader( @"<?xml version=""1.0"" encoding=""gb2312""?>
26. <int>10</int>"))
27.     {
28.          //声明序列化对象实例serializer
29.         XmlSerializer serializer = new XmlSerializer( typeof( int));
30.          //反序列化，并将反序列化结果值赋给变量i
31.          int i = ( int)serializer.Deserialize(rdr);
32.          //输出反序列化结果
33.         Console.WriteLine( "i = " + i);
34.         Console.Read();
35.     }
36. }
37. 以上代码用最简单的方式说明了xml序列化和反序列化的过程，.Net系统类库为我们做了大量的工作，序列化和反序列化都非常简单。但是在现实中业务需求往往比较复杂，不可能只简单的序列化一个 int变量，显示中我们需要对复杂类型进行可控制的序列化。
39. 自定义对象的Xml序列化：
41. System.Xml.Serialization命名空间中有一系列的特性类，用来控制复杂类型序列化的控制。例如XmlElementAttribute、XmlAttributeAttribute、XmlArrayAttribute、XmlArrayItemAttribute、XmlRootAttribute等等。
43. 看一个小例子，有一个自定义类Cat，Cat类有三个属性分别为Color，Saying，Speed。
45. namespace UseXmlSerialization
46. {
47.      class Program
48.     {
49.          static void Main(string[] args)
50.         {
51.              //声明一个猫咪对象
52.              var c = new Cat { Color = "White", Speed = 10, Saying = "White or black,  so long as the cat can catch mice,  it is a good cat" };
53.  
54.              //序列化这个对象
55.             XmlSerializer serializer = new XmlSerializer( typeof(Cat));
56.  
57.              //将对象序列化输出到控制台
58.             serializer.Serialize(Console.Out, c);
59.  
60.             Console.Read();
61.         }
62.     }
63.  
64.     [ XmlRoot("cat")]
65.      public class Cat
66.     {
67.          //定义Color属性的序列化为cat节点的属性
68.         [ XmlAttribute("color")]
69.          public string Color { get; set; }
70.  
71.          //要求不序列化Speed属性
72.         [ XmlIgnore]
73.          public int Speed { get; set; }
74.  
75.          //设置Saying属性序列化为Xml子元素
76.         [ XmlElement("saying")]
77.          public string Saying { get; set; }
78.     }
79. }
80. 可以使用XmlElement指定属性序列化为子节点（默认情况会序列化为子节点）；或者使用XmlAttribute特性制定属性序列化为Xml节点的属性；还可以通过XmlIgnore特性修饰要求序列化程序不序列化修饰属性。
82. 对象数组的Xml序列化：
84. 数组的Xml序列化需要使用XmlArrayAttribute和XmlArrayItemAttribute；XmlArrayAttribute指定数组元素的Xml节点名，XmlArrayItemAttribute指定数组元素的Xml节点名。
86. 如下代码示例：
88. using System;
89. using System.Collections.Generic;
90. using System.Linq;
91. using System.Text;
92. using System.Xml.Serialization;
93.  
94. namespace UseXmlSerialization
95. {
96.      class Program
97.     {
98.          static void Main(string[] args)
99.         {
100.              //声明一个猫咪对象
101.              var cWhite = new Cat { Color = "White", Speed = 10, Saying = "White or black,  so long as the cat can catch mice,  it is a good cat" };
102.              var cBlack = new Cat { Color = "Black", Speed = 10, Saying = "White or black,  so long as the cat can catch mice,  it is a good cat" };
103.  
104.             CatCollection cc = new CatCollection { Cats = new Cat[] { cWhite,cBlack} };
105.  
106.              //序列化这个对象
107.             XmlSerializer serializer = new XmlSerializer( typeof(CatCollection));
108.  
109.              //将对象序列化输出到控制台
110.             serializer.Serialize(Console.Out, cc);
111.  
112.             Console.Read();
113.         }
114.     }
115.  
116.     [ XmlRoot("cats")]
117.      public class CatCollection
118.     {
119.         [ XmlArray("items"),XmlArrayItem("item")]
120.          public Cat[] Cats { get; set; }
121.     }
122.  
123.     [ XmlRoot("cat")]
124.      public class Cat
125.     {
126.          //定义Color属性的序列化为cat节点的属性
127.         [ XmlAttribute("color")]
128.          public string Color { get; set; }
129.  
130.          //要求不序列化Speed属性
131.         [ XmlIgnore]
132.          public int Speed { get; set; }
133.  
134.          //设置Saying属性序列化为Xml子元素
135.         [ XmlElement("saying")]
136.          public string Saying { get; set; }
137.     }
138. }
139. 以上代码将输出：
141. <?xml version= "1.0" encoding= "gb2312"?>
142. <cats xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd= "http://ww
143. w.w3.org/2001/XMLSchema">
144.   <items>
145.     <item color= "White">
146.       <saying>White or black,  so long as the cat can catch mice,  it is a good
147. cat</saying>
148.     </item>
149.     <item color= "Black">
150.       <saying>White or black,  so long as the cat can catch mice,  it is a good
151. cat</saying>
152.     </item>
153.   </items>
154. </cats>
155. XmlSerializer内存泄漏问题：
157. 仔细看了下msdn，确实存在泄漏的情况，msdn说明如下：
159. 动态生成的程序集
161. 为了提高性能，XML 序列化基础结构将动态生成程序集，以序列化和反序列化指定类型。此基础结构将查找并重复使用这些程序集。此行为仅在使用以下构造函数时发生：
163. XmlSerializer(Type)
164. XmlSerializer.XmlSerializer(Type, String)
166. 如果使用任何其他构造函数，则会生成同一程序集的多个版本，且绝不会被卸载，这将导致内存泄漏和性能降低。最简单的解决方案是使用先前提到的两个构造函数的其中一个。否则，必须在 Hashtable 中缓存程序集，如以下示例中所示。
168. 也就是说我们在使用XmlSerializer序列化，初始化XmlSerializer对象时最好使用下面两个构造函数否则会引起内存泄漏。
169. XmlSerializer(Type)
170. XmlSerializer.XmlSerializer(Type, String)