DatacontractSerializer序列化

DatacontractSerializer在命名空间System.Runtime.Serialization下。它能够序列化DataContract、DataMember标记的类。

一、序列化规则：

1.没有显式声明DataMember特性的成员不会参与序列化。

2.DataMember标记的属性必须是可读可写的，否则会序列化异常。

3.所有元素序列化后都是XmlElement形式（不同于XmlSerializer的XmlAttribute可以将元素序列化到元素属性中）。

4.序列化后的元素顺序：父类元素在前，子类元素在后。同一类型中的数据成员按字母顺序排序。

5.默认的命名空间为http://schemas.datacontract.org/2004/07/+数据契约所在类型的名称。

常用序列化代码：

using System.Xml;

using System.Xml.Serialization;

using System.Runtime.Serialization;

namespace ConsoleApplication1

{

    public class PublicFunction

    {

        //序列化到XmlNode

        public static void SerializeByDataContract<T>(T t, out XmlNode node)

        {

            DataContractSerializer datacontractSerializer = new DataContractSerializer(typeof(T));

            XmlDocument doc = new XmlDocument();

            using (MemoryStream ms = new MemoryStream())

            {

                datacontractSerializer.WriteObject(ms,t);

                ms.Position = 0;

                doc.Load(ms);

                node = doc.LastChild;

            }

        }

          //反序列化XmlNode中的数据

        public static void DeserializeByDataContract<T>(XmlNode node, out T t)

        {

            DataContractSerializer datacontractSerializer = new DataContractSerializer(typeof(T));

            using (XmlReader reader = new XmlNodeReader(node))

            {

              t=(T)datacontractSerializer.ReadObject(reader);

            }

        }

        //序列化到文件

        public static void SerializeByDataContractWhithFile<T>(T t, string file)

        {

            DataContractSerializer datacontractSerializer = new DataContractSerializer(typeof(T));

            using (XmlTextWriter writer = new XmlTextWriter(file, Encoding.UTF8))

            {

 　　　　　　　　writer.Formatting = Formatting.Indented;

　　　　　　　　 datacontractSerializer.WriteObject(writer,t);

            }

        }

        //从文件反序列化

        public static void DeSerializeByDataContractWhithFile<T>(string file,out T t)

        {

            t = default(T);

            DataContractSerializer datacontractSerializer = new DataContractSerializer(typeof(T));

            using (XmlReader reader = new XmlTextReader(file))

            {

              t=(T)datacontractSerializer.ReadObject(reader);

            }

        }

     }

}

序列化实例：

using System.ServiceModel;

using System.Runtime.Serialization;

namespace ConsoleApplication1

{

    class Program

    {

        static void Main(string[] args)

        {

            Order order = new Order();

            PublicFunction.SerializeByDataContractWhithFile<Order>(order, @"D:\1.txt");

        }

    }

    [DataContract]

    public class OrderBase

    {

        [DataMember(Name="总价",Order=1)]

        public double totalPrice;

        [DataMember(Name = "消费者", Order = 2)]

        public string Customer;

        [DataMember(Name = "标识", Order = 3)]

        public Guid guid;

        public DateTime time;

        public OrderBase()

        {

            time = DateTime.Now;

            totalPrice = 86.5;

            Customer = "lh";

            guid = Guid.NewGuid();

            time = DateTime.Now;

        }

    }

    [DataContract]

    public class Order : OrderBase

    {

         [DataMember(Name="付款方式",Order=1)]

         public string paymentType;

         public Order()

             : base()

         {

             paymentType = "Cash";

         }

    }

}

序列化结果：

<Order xmlns:i="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://schemas.datacontract.org/2004/07/ConsoleApplication1">

  <总价>86.5</总价>

  <消费者>lh</消费者>

  <标识>933e5fa0-3655-4369-89db-2257d7db3078</标识>

  <付款方式>Cash</付款方式>

</Order>

可以看到OrderBase类的time属性没有使用DataMember特性，不会被序列化。

如下代码，A中的IsSet是只读，没有设置set。

 class Program

    {

        static void Main(string[] args)

        {

            A a = new A();

            XmlNode node = null;

             try
            {
                SerializeByDataContract<A>(a, out node);
            }
            catch (Exception e)
            {
                Console.WriteLine("Message:{0} \nStackTrace:{1}", e.Message, e.StackTrace);
            }      
       }

    }

    [DataContract]

    public class A

    {

        private bool isSet;

        [DataMember]

        public bool IsSet

        {

            get

            {

                return isSet;

            }

        }

    }

运行时发生异常，DataMember标识的属性必须是可读可写的，必须有get、set操作。

二、设置最大序列化个数

1.使用下面DataContractSerializer构造函数指定一次可序列化的最大个数。

public DataContractSerializer(Type type, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);

 //序列化到文件并指定最大序列化个数

  public static void SerializeByDataContractWhithFile<T>(T t, string file,int maxItemsIObjectGraph)

  {

      DataContractSerializer datacontractSerializer = new DataContractSerializer(typeof(T), null, maxItemsInObjectGraph, false, false, null);

      using (XmlWriter writer = new XmlTextWriter(file, Encoding.UTF8))

      {

        datacontractSerializer.WriteObject(writer,t);

      }

  }

序列化：

class Program

    {

        static void Main(string[] args)

        {

            List<Order> listOrder = new List<Order>();

            for (int i = 0; i < 10; i++)

            {

                listOrder.Add(new Order());

            }

            Order order = new Order();

            PublicFunction.SerializeByDataContractWhithFile(listOrder, @"D:\1.txt",50);

        }

    }

运行后抛出异常，System.Runtime.Serialization.SerializationException: 对象图中可以序列化或反序列化的项目数目上限为“50”。请更改对象图或增加 MaxItemsInObjectGraph 的配额。

listOrder本身算一个对象，Order中DataMember属性设置的字段有4个，Order自身算一个，于是总数为（4+1）*10+1=51个，超过了设置的50上限。

2.DataContractSerializer是WCF默认的序列化器，通过ServiceBehavior设置整个服务的最大序列化数，如果客户端调用InsertOrder方法中的listOrder超过10个，则会报SerializationException异常。

[ServiceBehavior(MaxItemsInObjectGraph=50)]

    public class OrderService : IOrderService

    {

        public void InsertOrder(List<Order> listOrder)

        {

        }

    }

    [ServiceContract]

    public interface IOrderService

    {

        [OperationContract]

        void InsertOrder(List<Order> listOrder);

    }

三、保持对象现有引用结构

对于对象中的多个字段指向同一个引用，在序列化时可以选择是否对它们都进行序列化。

 //序列化到文件并指定最大序列化个数,是否保证现有引用结构

   public static void SerializeByDataContractWhithFile<T>(T t, string file, bool preserverReference)

   {

       DataContractSerializer datacontractSerializer = new DataContractSerializer(typeof(T), null, int.MaxValue, false, preserverReference, null);

       using (XmlWriter writer = new XmlTextWriter(file, Encoding.UTF8))

       {

           datacontractSerializer.WriteObject(writer, t);

       }

  }

class Program

    {

        static void Main(string[] args)

        {

            CommonTest test = new CommonTest();

            test.order2 = test.order1 = new Order();

            PublicFunction.SerializeByDataContractWhithFile<CommonTest>(test, @"D:\1.txt", true);

        }

    }

     [DataContract]

    public class CommonTest

    {

         [DataMember]

         public Order order1;

         [DataMember]

         public Order order2;

    }

序列化后的结果为：

<CommonTest xmlns:i="http://www.w3.org/2001/XMLSchema-instance"

z:Id="1" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"

xmlns="http://schemas.datacontract.org/2004/07/ConsoleApplication1">

<order1 z:Id="2">

  <总价>86.5</总价>

  <消费者 z:Id="3">lh</消费者>

  <标识>cd792ed6-7701-48bd-817f-57605877b8e4</标识>

  <付款方式 z:Id="4">Cash</付款方式></order1>

  <order2 z:Ref="2" i:nil="true" />

</CommonTest>

可以看出，并没有对order2进行序列化，因为它们指向同一个引用。

四、对未知类型的处理

1.KnowType特性

标签类似于XmlSerializer的XmlInclude标签，用于声明为基类或者接口的对象，实际指向子类或实现类的对象情况下，可以正确序列化为指定的类型。

class Program

    {

        static void Main(string[] args)

        {

            KonwTypeBaseTest test1 = new KnowTypeTest { order = new Order() };

            PublicFunction.SerializeByDataContractWhithFile<KonwTypeBaseTest>(test1, @"D:\1.txt");

            IKonwType test2 = new KnowTypeTest { order = new Order() };

            PublicFunction.SerializeByDataContractWhithFile<IKonwType>(test2, @"D:\2.txt");

        }

    }

    [DataContract]

    [KnownType(typeof(KnowTypeTest))]

     public abstract class KonwTypeBaseTest

     {

     }

     public interface IKonwType

     {

     }

     [DataContract]

     public class KnowTypeTest : KonwTypeBaseTest, IKonwType

     {

         [DataMember]

         public Order order;

     }

test1基于基类进行序列化，结果为：

<KonwTypeBaseTest xmlns:i="http://www.w3.org/2001/XMLSchema-instance"

i:type="KnowTypeTest" xmlns="http://schemas.datacontract.org/2004/07/ConsoleApplication1">

<order>

  <总价>86.5</总价>

  <消费者>lh</消费者>

  <标识>e954f5ff-c2e2-47ee-86a8-46f9bbf88ce3</标识>

  <付款方式>Cash</付款方式>

</order>

</KonwTypeBaseTest>

根节点名称为KonwTypeBaseTest。

test2基于接口进行序列化，结果为：

<z:anyType xmlns:i="http://www.w3.org/2001/XMLSchema-instance"

  xmlns:d1p1="http://schemas.datacontract.org/2004/07/ConsoleApplication1"

  i:type="d1p1:KnowTypeTest"

  xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">

  <d1p1:order>

    <d1p1:总价>86.5</d1p1:总价>

    <d1p1:消费者>lh</d1p1:消费者>

    <d1p1:标识>fe80c5c1-d44b-4e7a-822e-758f645c99f7</d1p1:标识>

    <d1p1:付款方式>Cash</d1p1:付款方式>

  </d1p1:order>

</z:anyType>

根结点名称为anyType，意味着客户端可以传入任何类型，因此在WCF操作方法中最好不要使用接口类型的参数。

2.ServiceKonwType

WCF中，在声明ServiceContract的时候通过ServiceKonwType指定涉及的类。

 [ServiceContract]

    [ServiceKnownType(typeof(KnowTypeTest))]

    public interface IOrderService

    {

        [OperationContract]

        void TestAbstract(KonwTypeBaseTest test);

    }

五、泛型数据的序列化

class Program

    {

        static void Main(string[] args)

        {

            Bill<Test1, Test2> bill = new Bill<Test1, Test2> { t1 = new Test1(), t2 = new Test2() };

            PublicFunction.SerializeByDataContractWhithFile<Bill<Test1, Test2>>(bill, @"D:\1.txt");

        }

    }

    [DataContract]

    public class Bill<T1, T2>

    {

        [DataMember]

        public T1 t1;

        [DataMember]

        public T2 t2;

    }

    [DataContract]

    public class Test1

    {

       [DataMember]

       public Order order1;

       public Test1()

       {

          order1 = new Order();

       }

    }

    [DataContract]

    public class Test2

    {

       [DataMember]

       public Order order2;

       public Test2()

       {

          order2 = new Order();

       }

    }

序列化结果：

<BillOfTest1Test2HtQdUIlS xmlns:i="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://schemas.datacontract.org/2004/07/ConsoleApplication1">

  <t1>

    <order1>

      	<总价>86.5</总价>

	<消费者>lh</消费者>

	<标识>30764490-8197-45e6-8a2f-2f3b3cda79bf</标识>

	<付款方式>Cash</付款方式>

     </order1>

  </t1>

   <t2>

     <order2>
        <总价>86.5</总价>

     	<消费者>lh</消费者>

     	<标识>96424ff5-5f9b-483b-afb2-17c98a8e45de</标识>

     	<付款方式>Cash</付款方式>

     </order2>

   </t2>

</BillOfTest1Test2HtQdUIlS>

根结点名称为类型名称+of+泛型参数实际名称1+泛型参数实际名称2...+命名空间的哈希值。但泛型变量序列化后的实际名称还是Bill定义时的t1和t2。

六、对数据契约集合的序列化

数据契约集合指的还集合中的数据使用了DataContract。如下所示，序列化声明时分别指定类型为Order[]，IEnumerable<Order>、IList<Order>、自定义的OrderCollection

序列化后，前3个文件中的结果都是一模一样的。

class Program

    {

        static void Main(string[] args)

        {

            Order[] oreders = new Order[] { new Order(), new Order() };

            PublicFunction.SerializeByDataContractWhithFile<Order[]>(oreders,@"D:\1.txt");

            PublicFunction.SerializeByDataContractWhithFile<IEnumerable<Order>>(oreders, @"D:\2.txt");

            PublicFunction.SerializeByDataContractWhithFile<IList<Order>>(oreders, @"D:\3.txt");

            OrderCollection collec=new OrderCollection{new Order(),new Order()};

            PublicFunction.SerializeByDataContractWhithFile<OrderCollection>(collec, @"D:\4.txt");

        }

    }

    [CollectionDataContract(Name = "Orders", Namespace = "http://www.cnblogs.com/lh218",ItemName="Add")]

    public class OrderCollection : IEnumerable<Order>

    {

        private IList<Order> list;

        public OrderCollection()

        {

            list = new List<Order>();

        }

        public void Add(Order order)

        {

          list.Add(order);

        }

        public IEnumerator<Order> GetEnumerator()

        {

            return list.GetEnumerator();

        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

        {

            return list.GetEnumerator();

        }

    }

<ArrayOfOrder xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/ConsoleApplication1">

  <Order>

    <总价>86.5</总价>

    <消费者>lh</消费者>

    <标识>e55e4643-9a31-487b-b72f-3d46bb80b16e</标识>

    <付款方式>Cash</付款方式>

  </Order>

  <Order>

    <总价>86.5</总价>

    <消费者>lh</消费者>

    <标识>7eedba11-bcdc-432b-8810-db471fcf2da4</标识>

    <付款方式>Cash</付款方式>

  </Order>

</ArrayOfOrder>

根节点名称为ArrayOfOrder，都将它看为数组类型。

第4个使用了CollectionDataContract特性，并且制定了名称、命名空间、子元素名称，序列化后结果为：

<Orders xmlns:i="http://www.w3.org/2001/XMLSchema-instance"

        xmlns:d1p1="http://schemas.datacontract.org/2004/07/ConsoleApplication1"

        xmlns="http://www.cnblogs.com/lh218">

  <Add>

    <d1p1:总价>86.5</d1p1:总价>

    <d1p1:消费者>lh</d1p1:消费者>

    <d1p1:标识>41997758-59a0-4d84-aa56-d3bb2426b43a</d1p1:标识>

    <d1p1:付款方式>Cash</d1p1:付款方式>

  </Add>

  <Add>

    <d1p1:总价>86.5</d1p1:总价>

    <d1p1:消费者>lh</d1p1:消费者>

    <d1p1:标识>2d4f4e40-9390-43aa-818b-6e8ec97254e6</d1p1:标识>

    <d1p1:付款方式>Cash</d1p1:付款方式>

  </Add>

</Orders>

七、字典数据契约

class Program

    {

        static void Main(string[] args)

        {

            myDictionart myd = new myDictionart();

            Order o1=new Order();

            myd.Add(o1.guid,o1);

            PublicFunction.SerializeByDataContractWhithFile<myDictionart>(myd, @"D:\1.txt");

            PublicFunction.SerializeByDataContractWhithFile<IDictionary<Guid,Order>>(myd, @"D:\2.txt");

        }

    }

    [CollectionDataContract(Name = "Orders", Namespace = "http://www.cnblogs.com/lh218", ItemName = "Add",KeyName="Guid",ValueName="Order")]

    public class myDictionart : Dictionary<Guid, Order>

    { 

    }

1.txt内容为：

<Orders xmlns:i="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://www.cnblogs.com/lh218">

  <Add>

    <Guid>c263740a-417e-4b10-8892-8e8a03fe6989</Guid>

    <Order xmlns:d3p1="http://schemas.datacontract.org/2004/07/ConsoleApplication1">

      <d3p1:总价>86.5</d3p1:总价>

      <d3p1:消费者>lh</d3p1:消费者>

      <d3p1:标识>c263740a-417e-4b10-8892-8e8a03fe6989</d3p1:标识>

      <d3p1:付款方式>Cash</d3p1:付款方式>

    </Order>

  </Add>

</Orders>

2.txt内容为

<ArrayOfKeyValueOfguidOrdermcAJRImr xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">

  <KeyValueOfguidOrdermcAJRImr>

    <Key>f98fa454-ebe0-4086-b447-07d948862645</Key>

    <Value xmlns:d3p1="http://schemas.datacontract.org/2004/07/ConsoleApplication1">

      <d3p1:总价>86.5</d3p1:总价>

      <d3p1:消费者>lh</d3p1:消费者>

      <d3p1:标识>f98fa454-ebe0-4086-b447-07d948862645</d3p1:标识>

      <d3p1:付款方式>Cash</d3p1:付款方式>

    </Value>

  </KeyValueOfguidOrdermcAJRImr>

</ArrayOfKeyValueOfguidOrdermcAJRImr>

八、序列化Hashtable

 using System.Xml;

 using System.Runtime.Serialization;

 using System.Collections;

 namespace ConsoleApplication3

 {

     class Program

     {

         static void Main(string[] args)

         {

             Hashtable table = new Hashtable();

             Order order=new Order(DateTime.Now,12,"BillOrder");

             table.Add(1, order);

             Serialize<Hashtable>(table, @"D:\1.txt",new Type[]{typeof(Order)});

         }

         public static void Serialize<T>(T t, string path,Type[] types)

         {

             DataContractSerializer ser = new DataContractSerializer(typeof(T), types);

             using (XmlTextWriter writer = new XmlTextWriter(path, Encoding.UTF8))

             {

                 writer.Formatting = Formatting.Indented;

                 ser.WriteObject(writer, t);

             }

         }

     }

     [DataContract]

     public class Order

     {

         [DataMember]

         public DateTime date;

         [DataMember]

         public int price;

         [DataMember]

         public string name;

         public Order(DateTime date, int price, string name)

         {

             this.date = date;

             this.price = price;

             this.name = name;

         }

        public Order()

         { }

     }

 }

序列化的结果：

<ArrayOfKeyValueOfanyTypeanyType xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">

  <KeyValueOfanyTypeanyType>

    <Key xmlns:d3p1="http://www.w3.org/2001/XMLSchema" i:type="d3p1:int">1</Key>

    <Value xmlns:d3p1="http://schemas.datacontract.org/2004/07/ConsoleApplication3" i:type="d3p1:Order">

      <d3p1:date>2015-05-17T15:10:32.7811014+08:00</d3p1:date>

      <d3p1:name>BillOrder</d3p1:name>

      <d3p1:price>12</d3p1:price>

    </Value>

  </KeyValueOfanyTypeanyType>

</ArrayOfKeyValueOfanyTypeanyType>

Hashtable序列化的根结点名称为ArrayOfKeyValueOfanyTypeanyType，意味着是序列化时将key和value看成object类型。在WCF接口中尽量不要使用Hashtable、IList、IEnumerable、object等不确定类型的接口作为方法参数。或者使用确定类型的泛型版本，IList<T>、IEnumerable<T>等。

巴特西

DatacontractSerializer序列化

最新文章

热门文章