Collection主要是指像Array, ArrayList, List, Dictionary, HashTable这些数据类型，大家平时用的很多。如果一个类中有一个Collection类型的成员，在对这个类进行XML序列化的时候，应该如何处理？应该说在.net当中这是比较简单的，只要建立一个XmlSerializer类就可以帮你自动搞定，不过有的时候你可能需要对自动的序列化过程施加更多的控制，比如XML的结构是实现固定的，你必须按照要求去生成XML结构。
使用不同的属性可以灵活的控制生成的XML，这里我就不多介绍了，主要讲一下如何序列化比较复杂的Collection结构。下面的方法，对于所有实现了IEnumerable接口的Collection都有效。
我使用MSDN中的例子，不过没有使用数组或者ArrayList，而是使用了比较高级的数据类型List<T>，希望在讲解如何序列化XML的同时给使用List<T>的同学提供点参考。
序列化一个List<T>

下面的代码示范了如何序列化一个List<T>，实际上和序列化其它类一样，把这个类扔给Serialize（）函数即可。

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Xml.Serialization; 
6. using System.IO; 
7.   
8. namespace SerializeCollection 
9. { 
10.     class Program 
11.     { 
12.         static void Main(string[] args) 
13.         { 
14.             Program test = new Program(); 
15.             test.SerializeDocument("e:\\books.xml"); 
16.         } 
17.   
18.         public void SerializeDocument(string filename) 
19.         { 
20.             // Creates a new XmlSerializer. 
21.             XmlSerializer s = 
22.             new XmlSerializer(typeof(MyRootClass)); 
23.   
24.             // Writing the file requires a StreamWriter. 
25.             TextWriter myWriter = new StreamWriter(filename); 
26.   
27.             // Creates an instance of the class to serialize.  
28.             MyRootClass myRootClass = new MyRootClass(); 
29.              
30.             //create items 
31.             Item item1 = new Item(); 
32.             // Sets the objects' properties. 
33.             item1.ItemName = "Widget1"; 
34.             item1.ItemCode = "w1"; 
35.             item1.ItemPrice = 231; 
36.             item1.ItemQuantity = 3; 
37.   
38.              
39.             Item item2 = new Item(); 
40.             // Sets the objects' properties. 
41.             item2.ItemName = "Widget2"; 
42.             item2.ItemCode = "w2"; 
43.             item2.ItemPrice = 800; 
44.             item2.ItemQuantity = 2; 
45.   
46.             // Sets the class's Items property to the list. 
47.             myRootClass.Items.Add(item1); 
48.             myRootClass.Items.Add(item2); 
49.   
50.             /* Serializes the class, writes it to disk, and closes  
51.                the TextWriter. */ 
52.             s.Serialize(myWriter, myRootClass); 
53.             myWriter.Close(); 
54.         } 
55.   
56.     } 
57.   
58.     // This is the class that will be serialized. 
59.     [Serializable] 
60.     public class MyRootClass 
61.     { 
62.         public MyRootClass() 
63.         { 
64.             items = new List<Item>(); 
65.         } 
66.   
67.         private List<Item> items; 
68.   
69.         public List<Item> Items 
70.         { 
71.             get { return items; } 
72.             set { items = value; } 
73.         } 
74.     } 
75.   
76.     public class Item 
77.     { 
78.         [XmlElement(ElementName = "OrderItem")] 
79.         public string ItemName; 
80.         public string ItemCode; 
81.         public decimal ItemPrice; 
82.         public int ItemQuantity; 
83.     } 
84.   
85.   
86. } 

最后序列化成的XML：

1. <?xml version="1.0" encoding="utf-8"?> 
2. <MyRootClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
3.   <Items> 
4.     <Item> 
5.       <OrderItem>Widget1</OrderItem> 
6.       <ItemCode>w1</ItemCode> 
7.       <ItemPrice>231</ItemPrice> 
8.       <ItemQuantity>3</ItemQuantity> 
9.     </Item> 
10.     <Item> 
11.       <OrderItem>Widget2</OrderItem> 
12.       <ItemCode>w2</ItemCode> 
13.       <ItemPrice>800</ItemPrice> 
14.       <ItemQuantity>2</ItemQuantity> 
15.     </Item> 
16.   </Items> 
17. </MyRootClass> 

如果这个List<T>中的成员的类还有继承关系

现在把情况变得复杂一点，因为多态，List<T>中的类可能是指定类型的子类型，这个时候会出现什么情况呢？
我们增加一个BookItem类，继承自Item 类。

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Xml.Serialization; 
6. using System.IO; 
7.   
8. namespace SerializeCollection 
9. { 
10.     class Program 
11.     { 
12.         static void Main(string[] args) 
13.         { 
14.             Program test = new Program(); 
15.             test.SerializeDocument("e:\\books.xml"); 
16.         } 
17.   
18.         public void SerializeDocument(string filename) 
19.         { 
20.             // Creates a new XmlSerializer. 
21.             XmlSerializer s = 
22.             new XmlSerializer(typeof(MyRootClass)); 
23.   
24.             // Writing the file requires a StreamWriter. 
25.             TextWriter myWriter = new StreamWriter(filename); 
26.   
27.             // Creates an instance of the class to serialize.  
28.             MyRootClass myRootClass = new MyRootClass(); 
29.   
30.             /* Uses a more advanced method of creating an list: 
31.          create instances of the Item and BookItem, where BookItem  
32.          is derived from Item. */ 
33.             Item item1 = new Item(); 
34.             // Sets the objects' properties. 
35.             item1.ItemName = "Widget1"; 
36.             item1.ItemCode = "w1"; 
37.             item1.ItemPrice = 231; 
38.             item1.ItemQuantity = 3; 
39.   
40.             BookItem bookItem = new BookItem(); 
41.             // Sets the objects' properties. 
42.             bookItem.ItemCode = "w2"; 
43.             bookItem.ItemPrice = 123; 
44.             bookItem.ItemQuantity = 7; 
45.             bookItem.ISBN = "34982333"; 
46.             bookItem.Title = "Book of Widgets"; 
47.             bookItem.Author = "John Smith"; 
48.   
49.             // Sets the class's Items property to the list. 
50.             myRootClass.Items.Add(item1); 
51.             myRootClass.Items.Add(bookItem); 
52.   
53.             /* Serializes the class, writes it to disk, and closes  
54.                the TextWriter. */ 
55.             s.Serialize(myWriter, myRootClass); 
56.             myWriter.Close(); 
57.         } 
58.   
59.     } 
60.   
61.     // This is the class that will be serialized. 
62.     [Serializable] 
63.     public class MyRootClass 
64.     { 
65.         public MyRootClass() 
66.         { 
67.             items = new List<Item>(); 
68.         } 
69.   
70.         private List<Item> items; 
71.   
72.         public List<Item> Items 
73.         { 
74.             get { return items; } 
75.             set { items = value; } 
76.         } 
77.     } 
78.   
79.     public class Item 
80.     { 
81.         [XmlElement(ElementName = "OrderItem")] 
82.         public string ItemName; 
83.         public string ItemCode; 
84.         public decimal ItemPrice; 
85.         public int ItemQuantity; 
86.     } 
87.   
88.     public class BookItem : Item 
89.     { 
90.         public string Title; 
91.         public string Author; 
92.         public string ISBN; 
93.     } 
94.   
95.   
96.   
97. } 

修改代码后，我们再运行，出现如下错误“不应是类型 SerializeCollection.BookItem。使用 XmlInclude 或 SoapInclude 属性静态指定非已知的类型”，看来是系统在做序列化的时候，搞不清楚List中的成员到底是什么类型。这个时候就要使用XmlArrayItem来帮忙了。MyRootClass类的Item成员前加入XmlArrayItem标志。

1. [XmlArrayItem(ElementName= "Item",  
2.    IsNullable=true, 
3.    Type = typeof(Item), 
4.    Namespace = "http://www.aboutdnn.com"), 
5.    XmlArrayItem(ElementName = "BookItem",  
6.    IsNullable = true,  
7.    Type = typeof(BookItem), 
8.    Namespace = http://www.aboutdnn.com)] 

修改后的代码如下：

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Xml.Serialization; 
6. using System.IO; 
7.   
8. namespace SerializeCollection 
9. { 
10.     class Program 
11.     { 
12.         static void Main(string[] args) 
13.         { 
14.             Program test = new Program(); 
15.             test.SerializeDocument("e:\\books.xml"); 
16.         } 
17.   
18.         public void SerializeDocument(string filename) 
19.         { 
20.             // Creates a new XmlSerializer. 
21.             XmlSerializer s = 
22.             new XmlSerializer(typeof(MyRootClass)); 
23.   
24.             // Writing the file requires a StreamWriter. 
25.             TextWriter myWriter = new StreamWriter(filename); 
26.   
27.             // Creates an instance of the class to serialize.  
28.             MyRootClass myRootClass = new MyRootClass(); 
29.   
30.             /* Uses a more advanced method of creating an list: 
31.          create instances of the Item and BookItem, where BookItem  
32.          is derived from Item. */ 
33.             Item item1 = new Item(); 
34.             // Sets the objects' properties. 
35.             item1.ItemName = "Widget1"; 
36.             item1.ItemCode = "w1"; 
37.             item1.ItemPrice = 231; 
38.             item1.ItemQuantity = 3; 
39.   
40.             BookItem bookItem = new BookItem(); 
41.             // Sets the objects' properties. 
42.             bookItem.ItemCode = "w2"; 
43.             bookItem.ItemPrice = 123; 
44.             bookItem.ItemQuantity = 7; 
45.             bookItem.ISBN = "34982333"; 
46.             bookItem.Title = "Book of Widgets"; 
47.             bookItem.Author = "John Smith"; 
48.   
49.             // Sets the class's Items property to the list. 
50.             myRootClass.Items.Add(item1); 
51.             myRootClass.Items.Add(bookItem); 
52.   
53.             /* Serializes the class, writes it to disk, and closes  
54.                the TextWriter. */ 
55.             s.Serialize(myWriter, myRootClass); 
56.             myWriter.Close(); 
57.         } 
58.   
59.     } 
60.   
61.     // This is the class that will be serialized. 
62.     [Serializable] 
63.     public class MyRootClass 
64.     { 
65.         public MyRootClass() 
66.         { 
67.             items = new List<Item>(); 
68.         } 
69.   
70.         private List<Item> items; 
71.   
72.         [XmlArrayItem(ElementName = "Item", 
73.    IsNullable = true, 
74.    Type = typeof(Item), 
75.    Namespace = "http://www.aboutdnn.com"), 
76.    XmlArrayItem(ElementName = "BookItem", 
77.    IsNullable = true, 
78.    Type = typeof(BookItem), 
79.    Namespace = "http://www.aboutdnn.com")] 
80.   
81.         public List<Item> Items 
82.         { 
83.             get { return items; } 
84.             set { items = value; } 
85.         } 
86.     } 
87.   
88.     public class Item 
89.     { 
90.         [XmlElement(ElementName = "OrderItem")] 
91.         public string ItemName; 
92.         public string ItemCode; 
93.         public decimal ItemPrice; 
94.         public int ItemQuantity; 
95.     } 
96.   
97.     public class BookItem : Item 
98.     { 
99.         public string Title; 
100.         public string Author; 
101.         public string ISBN; 
102.     } 
103.   
104.   
105.   
106. } 

序列化后的XML如下：

1. <?xml version="1.0" encoding="utf-8"?> 
2. <MyRootClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
3.   <Items> 
4.     <Item xmlns="http://www.aboutdnn.com"> 
5.       <OrderItem>Widget1</OrderItem> 
6.       <ItemCode>w1</ItemCode> 
7.       <ItemPrice>231</ItemPrice> 
8.       <ItemQuantity>3</ItemQuantity> 
9.     </Item> 
10.     <BookItem xmlns="http://www.aboutdnn.com"> 
11.       <ItemCode>w2</ItemCode> 
12.       <ItemPrice>123</ItemPrice> 
13.       <ItemQuantity>7</ItemQuantity> 
14.       <Title>Book of Widgets</Title> 
15.       <Author>John Smith</Author> 
16.       <ISBN>34982333</ISBN> 
17.     </BookItem> 
18.   </Items> 
19. </MyRootClass> 

可以看到，已经根据不同的数据类型，序列化为不同名字的节点。这个时候，如果你还想修改XML中<Items>节点的名字或者添加属性，XmlArrayAttribute可以帮你的忙，这个你可以自己试试。

参考文档：

XmlArrayAttribute Class：http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlarrayattribute.aspx