WCF 学习之数据契约（DataContract）

        在 WCF 服务中，WCF 的通信可以理解为一种消息交换，消息交换就需要有契约使交换的双方达成一致理解，服务契约的操作描述了需要采用的消息交换模式和消息结构，数据契约就用来规范整个通信过程的消息结构。

一、数据契约特性（DataContractAttribute）和数据成员特性（DataMemberAttribute）

         在 WCF 中定义了用在类（class）、枚举（enum）和结构（struct）上的 System.Runtime.Serialization.DataContractAttribute 特性，它标识类型为数据契约，DataContractAttribute 是不可以继承的，因此所有作为数据契约的类型都必须应用该特性。DataContractAttribute  中只定义了3个属性成员：是否保持对象现有的引用结构（IsReference）、数据契约的名称（Name）、数据契约的命名空间（Namespace）。

         数据契约中的成员采用显示选择机制，只用应用了 System.Runtime.Serialization.DataMemberAttribute 特性的属性和字段才可以成为数据成员。DataMemberAttribute 只能应用到属性和字段上，它属性Order用来控制数据成员序列化时的排序。

数据契约类型声明：

[DataContract(Namespace = "http://www.ainote.cn")]
   public class Customer
   {
       [DataMember(Order = 1)]
       public string FirstName { get; set; }
       [DataMember(Order = 2)]
       public string LastName { get; set; }
       [DataMember(Order = 3)]
       public string Gender { get; set; }
   }

二、数据契约序列化器（DataContractSerializer）

       WCF 中针对数据契约定义了有一个 System.Runtime.Serialization.DataContractSerializer 序列化器。在 DataContractSerializer 中通过 WriteObject 和ReadObject 两个方法完成序列化和反序列化，它具有5个重要的属性：用于控制序列化、反序列化和契约的导入和导出的数据契约代理类对象（DataContractSurrogate）、用于解决通信双方契约不一致时数据传送和回传过程中数据丢失的扩展数据对象（IgnoreExtensionDataObject）、明确对象所引用的真实类型的已知类型（KnownTypes）、序列化与反序列化允许的最大对象数（MaxItemInObjectGraph）、是否保持现有对象的引用结构（PreserveObjectReferences）。在DataContractSerializer 的构造函数中对应上述属性都有相应的参数，通过参数控制序列化时，数据的接口和类型等。

      在使用 DataContractSerializer 类型基于接口和基类进行序列化时，需要通过构造函数指定对象所引用的真实类型的已知类型（KnownTypes）。在数据契约中通过应用 System.Runtime.Serialization.KnownTypeAttribute 特性在数据契约的类型上指定已知类型，KnownTypeAttribute 可以通过两种方式设置已知类型：直接指定已知类型和通过返回类型实现了 IEnumerable<Type> 的静态无参方法指定已知类型。

[DataContract]
   //两种设置已知类型序列化的方式
  // [KnownType(typeof(Order))]
   [KnownType("GetknownTypes")]
   public class OrderBase:IOrder
   {
       public static IEnumerable<Type> GetknownTypes() {
       yield return typeof(Order);
       }
       [DataMember]
       public Guid OrderID { get; set; }
       [DataMember]
       public DateTime Date { get; set; }
       [DataMember]
       public string Customer { get; set; }
       [DataMember]
       public string ShipAddress { get; set; }
       public double TotalPrice { get; set; }
   }

数据契约代理 IDataContractSurrogate 接口定义了3个于序列化有关的方法：GetDataContractType-获取用于序列化、反序列化或数据导入、导出的数据契约类型；GetObjectToSerialize -在序列化之前获取序列化的对象；GetDeserializedObject-完成反序列化时获得被反序列化生成的对象。

public class UserDataContractSurrogate:IDataContractSurrogate
    {
        public Type GetDataContractType(Type type) {
            if (type==typeof(Contact))
            {
                return typeof(Customer);
            }
            return type;
        }
        public object GetDeserializedObject(object obj, Type targetType) {
            Customer customer = obj as Customer;
            if (customer==null)
            {
                return obj;
            }
            return new Contact {
            PersonName=customer.FirstName+" "+customer.LastName,
            Sex=customer.Gender
            };
        }
        public object GetObjectToSerialize(object obj, Type targetType)
        {
            Contact contact = obj as Contact;
            if (contact == null)
            {
                return obj;
            }
            return new Customer
            {
                FirstName = contact.PersonName.Split(" ".ToCharArray())[0],
                LastName = contact.PersonName.Split(" ".ToCharArray())[1],
                Gender = contact.Sex
            };
//其他方法
        }

三、集合数据契约

泛型数据契约和集合数据契约

       在 WCF 泛型类型也可以定义成数据契约，泛型数据契约序列化时它根节点名称格式为：{类型名称}+Of+{泛型实参类型1}+{泛型实参类型2}...+{哈希值}，也可以通过DataContractAttribute 的Name属性指定一个唯一的名称。

      对于实现了IEnumerable 或 IEnumerable<T> 集合类型，如果他的元素类型是数据契约，该集合为数据契约集合。数据契约集合序列化：

        static void DataContractList()
        {
            Person person1 = new Person
            {
                ID = Guid.NewGuid(),
                Name = "Stone",
                Phone = "18080856212",
                Address = "四川 成都"
            };
            Person person2 = new Person
            {
                ID = Guid.NewGuid(),
                Name = "Peng",
                Phone = "13540859823",
                Address = "四川 成都 高新区"

            };
            Person[] persons = new Person[] { person1, person2 };
            string path = @"E:\CSharp\Stone.Serialization.Client\Test\";
            //Root 节点名称为ArrayOfPerson，ArrayOf+{类型名称}
            Serialize<Person[]>(persons, path + "PersonArray.xml");
            Serialize<IEnumerable<Person>>(persons, path + "PersonEnumerable.xml");
            Serialize<IList<Person>>(persons, path + "PersonList.xml");

            //IEnumerable和IList 序列化需要指定已知类型，Root节点名称为ArrayOfanyType,ArrayOf+Type
            Serialize<IEnumerable>(persons, path + "Person.IEnumerable.xml", true, typeof(Person));
            Serialize<IList>(persons, path + "Person.IList.xml", true, typeof(Person));
        }

代码中的前3种类型方式序列化后的数据结构一致，后两种的数据结构一致：

前3种类型方式序列化后XML：

<ArrayOfPerson xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.ainote.cn">
  <Person>
    <ID>cb824c10-13ab-430a-abd0-c66c4df7abc3</ID>
    <Name>Stone</Name>
    <Phone>18080856212</Phone>
    <Address>四川 成都</Address>
  </Person>
  <Person>
    <ID>a3acf0d5-8319-40cb-9b3e-d81bf65477f2</ID>
    <Name>Peng</Name>
    <Phone>13540859823</Phone>
    <Address>四川 成都 高新区</Address>
  </Person>
</ArrayOfPerson>

后2种类型方式序列化后XML：

<ArrayOfanyType xmlns:i="http://www.w3.org/2001/XMLSchema-instance" z:Id="1" z:Size="2" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
  <anyType z:Id="2" xmlns:d2p1="http://www.ainote.cn" i:type="d2p1:Person">
    <d2p1:ID>08a74b87-e78a-407a-9986-28df8c552f8e</d2p1:ID>
    <d2p1:Name z:Id="3">Stone</d2p1:Name>
    <d2p1:Phone z:Id="4">18080856212</d2p1:Phone>
    <d2p1:Address z:Id="5">四川 成都</d2p1:Address>
  </anyType>
  <anyType z:Id="6" xmlns:d2p1="http://www.ainote.cn" i:type="d2p1:Person">
    <d2p1:ID>adfe694f-9350-4cb3-97ef-aa346e5e6333</d2p1:ID>
    <d2p1:Name z:Id="7">Peng</d2p1:Name>
    <d2p1:Phone z:Id="8">13540859823</d2p1:Phone>
    <d2p1:Address z:Id="9">四川 成都 高新区</d2p1:Address>
  </anyType>
</ArrayOfanyType>

     通过在类型上应用CollectionDataContract特性，标识数据契约为集合数据契约，集合数据契约类型必须显式定义一个无参构造函数和一个返回类型为 void 的公共Add方法，Add方法的参数为集合数据契约类型的参数。

   1:   [CollectionDataContract(Namespace="http://www.ainote.cn",ItemName="Add")]

   2:      public class PersonList : IEnumerable<Person>

   3:      {

   4:          public PersonList() { }

   5:          public void Add(Person per)

   6:          {

   7:              this.Persons.Add(per);

   8:          }

   9:  //其他成员

  10:  }

字典数据契约

    字典数据契约是一种特殊的集合数据契约，它通过键-值对（key-value）的方式序列化到xml 元素名称,也可以通过CollectionDataContract特性的KeyName 和 ValueName属性指定键-值元素的名称。

字典数据契约序列化：

[CollectionDataContract(Name = "PersonDictionary",KeyName="PersonID",
       ValueName="PersonInfo",Namespace="http://www.ainote.cn")]
 public  class PersonDictionary:Dictionary<Guid,Person>
   {
     public PersonDictionary() { }
     public void Add(Guid key,Person value) {
         base.Add(key,value);
     }
   }

<PersonDictionary xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.ainote.cn">
  <KeyValueOfguidPersonBuvzgkHJ>
    <PersonID>bbd29a52-da43-4925-af0a-ea45024bca95</PersonID>
    <PersonInfo>
      <ID>bbd29a52-da43-4925-af0a-ea45024bca95</ID>
      <Name>Stone</Name>
      <Phone>18080856212</Phone>
      <Address>四川 成都</Address>
    </PersonInfo>
  </KeyValueOfguidPersonBuvzgkHJ>
  <KeyValueOfguidPersonBuvzgkHJ>
    <PersonID>cfbf233f-9a83-48a3-af8f-8934e42d7846</PersonID>
    <PersonInfo>
      <ID>cfbf233f-9a83-48a3-af8f-8934e42d7846</ID>
      <Name>Peng</Name>
      <Phone>13540859823</Phone>
      <Address>四川 成都 高新区</Address>
    </PersonInfo>
  </KeyValueOfguidPersonBuvzgkHJ>
</PersonDictionary>

    还可以通过实现了IDictionary或IDictionary<TKey,TValue> 接口的类型定义值为数据契约类型的数据契约字典。数据契约字典序列化：

static void DataContractDictionaryTest()
       {
           Person person1 = new Person
           {
               ID = Guid.NewGuid(),
               Name = "Stone",
               Phone = "18080856212",
               Address = "四川 成都"
           };
           Person person2 = new Person
           {
               ID = Guid.NewGuid(),
               Name = "Peng",
               Phone = "13540859823",
               Address = "四川 成都 高新区"

           };

           Dictionary<Guid, Person> dic = new Dictionary<Guid, Person>();
           dic.Add(person1.ID,person1);
           dic.Add(person2.ID, person2);
           string path = @"E:\CSharp\Stone.Serialization.Client\Test\";
           //  数据契约字典序列化

           Serialize<IDictionary<Guid, Person>>(dic, path + "Person.DataContractDictionary.xml", true, typeof(Person));
       }

<ArrayOfKeyValueOfguidPersonBuvzgkHJ xmlns:i="http://www.w3.org/2001/XMLSchema-instance" z:Id="1" z:Size="2" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
  <KeyValueOfguidPersonBuvzgkHJ>
    <Key>a3becf2a-f4b7-44c2-bf86-e707ea329ccb</Key>
    <Value xmlns:d3p1="http://www.ainote.cn" z:Id="2">
      <d3p1:ID>a3becf2a-f4b7-44c2-bf86-e707ea329ccb</d3p1:ID>
      <d3p1:Name z:Id="3">Stone</d3p1:Name>
      <d3p1:Phone z:Id="4">18080856212</d3p1:Phone>
      <d3p1:Address z:Id="5">四川 成都</d3p1:Address>
    </Value>
  </KeyValueOfguidPersonBuvzgkHJ>
  <KeyValueOfguidPersonBuvzgkHJ>
    <Key>ada2125d-634d-4c2f-afb0-231347898a77</Key>
    <Value xmlns:d3p1="http://www.ainote.cn" z:Id="6">
      <d3p1:ID>ada2125d-634d-4c2f-afb0-231347898a77</d3p1:ID>
      <d3p1:Name z:Id="7">Peng</d3p1:Name>
      <d3p1:Phone z:Id="8">13540859823</d3p1:Phone>
      <d3p1:Address z:Id="9">四川 成都 高新区</d3p1:Address>
    </Value>
  </KeyValueOfguidPersonBuvzgkHJ>
</ArrayOfKeyValueOfguidPersonBuvzgkHJ>

数据契约的核心是消息的序列化与反序列化，通过通过序列化器控制消息序列化和反序列化后的数据结构。

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。