数据契约的定义与数据契约序列化器（3）

通过MaxItemsInObjectGraph限定序列化对象的数量

拒绝服务（DoS- Denial of Service）是一种常用的黑客攻击行为，黑客通过生成大容量的数据频繁地对服务器发送请求，最终导致服务器不堪重负而崩溃。对于WCF的序列化或反序列化来说，数据的容量越大、成员越多、层次越深，序列化的时间就越长，耗用的资源就越多，如果黑客频繁地发送一个海量的数组过来，那么服务就会因为忙于进行反序列化的工作而没有足够的资源处理正常的请求，从而导致瘫痪。

在这种情况下，可以通过MaxItemsInObjectGraph这个属性设置DataContractSerializer允许被序列化或反序列化对象的数量上限，一旦超过设定的这个上限，序列化或反序列化的工作将会立即中止，从而在一定程度上解决了通过发送大集合数据形式的拒绝服务攻击。DataContractSerializer中定义了以下3个重载的构造函数使我们能够设定MaxItemsInObjectGraph属性。

1. public sealed class DataContractSerializer :
   XmlObjectSerializer  
2. {  
3.     //其他成员  
4.     public DataContractSerializer(Type type, 
   IEnumerable<Type> knownTypes,   
5.       int maxItemsInObjectGraph, bool 
   ignoreExtensionDataObject, bool   
6.       preserveObjectReferences, IDataContractSurrogate 
   dataContractSurrogate);  
7.  
8.     public DataContractSerializer(Type type, string 
   rootName, string   
9.       rootNamespace, IEnumerable<Type> knownTypes,
   int maxItemsInObjectGraph,   
10.       bool ignoreExtensionDataObject, bool 
    preserveObjectReferences,   
11.       IDataContractSurrogate dataContractSurrogate);  
12.  
13.     public DataContractSerializer(Type type, 
    XmlDictionaryString rootName,   
14.       XmlDictionaryString rootNamespace, 
    IEnumerable<Type> knownTypes, int   
15.       maxItemsInObjectGraph, bool 
    ignoreExtensionDataObject, bool   
16.       preserveObjectReferences, IDataContractSurrogate
    dataContractSurrogate);  
17.       
18.     public int MaxItemsInObjectGraph { get; }  
19. } 

那么DataContractSerializer在进行具体的序列化时，对象的个数如何计算呢？经过我的实验，发现采用的计算规则是这样的：对象自身算一个对象，所有成员及所有内嵌的成员都算一个对象。我们通过一个具体的例子来证实这一点，在上面定义的泛型Serialize方法上加另一个参数maxItemsInObjectGraph，并调用另一个构造函数来创建DataContractSerializer对象。

1. public static void Serialize<T>(T instance, 
   string fileName, int   
2.   maxItemsInObjectGraph)  
3. {  
4.     DataContractSerializer serializer = 
   new DataContractSerializer(typeof(T),   
5.       null,maxItemsInObjectGraph,false,false,null);  
6.     using (XmlWriter writer = new 
   XmlTextWriter(fileName, Encoding.UTF8))  
7.     {  
8.         serializer.WriteObject(writer, instance);  
9.     }  
10.     Process.Start(fileName);  
11. } 

我们现在准备调用上面的方法对一个集合对象进行序列化，为此定义了一个OrderCollection的类型，它直接继承了List<Order>。

1. public class OrderCollection : List<Order> 
2. { }  
3.  
4. [DataContract]  
5. public class Order  
6. {  
7.     [DataMember]  
8.     public Guid ID  
9.     { get; set; }  
10.  
11.     [DataMember]  
12.     public DateTime Date  
13.     { get; set; }  
14.  
15.     [DataMember]  
16.     public string Customer  
17.     { get; set; }  
18.  
19.     [DataMember]  
20.     public string ShipAddress  
21.     { get; set; }  
22. } 

在下面的代码中，创建了OrderCollection对象，并添加了10个Order对象，如果该对象被序列化，最终被序列化对象数量是多少呢？应该这样来算，OrderCollection对象本身算一个，每一个Order对象自身也算一个，Order对象具有4个属性，各算一个，那么最终计算出来的个数是10×5+1=51个。但是在调用Serialize方法的时候，指定的上限仅仅是10×5=50。所以当调用DataContractSerializer的WriteObject方法时，会抛出如图5-2所示的SerializationException异常。如果maxItemsInObjectGraph设为51则一切正常。

1. OrderCollection orders = new OrderCollection();  
2. for (int i = 0; i < 10; i++)  
3. {  
4.     Order order = new Order()  
5.     {  
6.         ID = Guid.NewGuid(),  
7.         Date = DateTime.Today,  
8.         Customer = "NCS",  
9.         ShipAddress = "#328, Airport Rd, 
   Industrial Park, Suzhou JiangSu   
10.           Province",  
11.     };  
12.     orders.Add(order);  
13. }  
14. Serialize(orders, @"E:\order.xml", 10*5);