wcf序列化

      一个基于SOA结构的互联系统（Connected System）通常由若干相互独立的子系统（Sub-System）组成，这些子系统可能一个独立的Application，也可以是由若干Application相互集成的小系统，各个子系统相互独立又相互关联。子系统之间的相互交互由Message来实现。子系统之间的相互交互本质上是一种消息的交互过程（Message Exchange）。

      Serialization可以把包含相同内容的数据从一种结构 (.NET Object) 转换成另一种结构 (XML) 。要实现在两种不同结构之间的转化，这两种结构之间必须存在一种Mapping。Serialization的实现由序列化器（Serializer）来负责。而Serializer则利用某种算法（Arithmetic）来提供这种Mapping。.NET Object通过Serialization转化成XML Infoset。但是要使数据能够通过网络协议在网络上传递，必须把生成的XML Infoset转化成字节流（Byte Stream），所以Encoding关注的是XML Infoset到字节流（Byte Stream）这一段转化的过程。在WCF中，有3中不同的方式可供选择：Binary；Text和MTOM（Message Transmit Optimized Mechanism）。Binary具有最好的Performance，Text具有最好的互操作性，MTOM则有利于大量数据的传送。

      Sterilization是基于Service Contract的——而实际上它也是定义在Service Contract中，放在Code中；而Encoding一般由Binding提供，它是和Service无关的，我们一般在Configuration中根据实际的需要选择我们合适的Encoding。WCF把Serialization和Encoding相互分离是有好处的，Serialization对部署环境的影响相对不大，具有相对的通用性，而Encoding则关系到访问Service的性能以及互操作性等方面，和部署环境紧密相关。

      Serialization 是通过Serializer来完成的，WCF中有3种不同的Serializer——DataContractSerializer（定义在System.RunTime.Serializtion namespace中）、XMLSerializer（定义在System.XML.Serialization namespace）和NetDataContractSerializer (定义在System.XML.Serialization namespace) 。他们以不同的方式实现.NET Object的Serialization。DataContractSerializer和NetDataContractSerializer基本上没有太大的区别，我们只讨论DataContractSerializer和XMLSerializer。DataContractSerializer为WCF默认的Serializer，如果没有显式规定采用另外一种Serializer，WCF会创建一个DataContractSerializer 序列化NET Object。首先我们来讨论DataContractSerializer采用怎样的一种Mapping方式来把.NET Object转化成XML。

      下面通过实例说明序列化过程： 

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;

namespace WCFSerialization
{
    [DataContract]
    public class Student
    {
        private Guid _studentID;
        private string _studentName;
        private int _studentAge;
        private bool _StudentSex;

        public Student(Guid id, string name, int age, bool sex)
        {
            this._studentID = id;
            this._studentName = name;
            this._studentAge = age;
            this._StudentSex = sex;
        }

        [DataMember]
        public Guid StudentID
        {
            get { return _studentID; }
            set { _studentID = value; }
        }

        [DataMember]
        public string StudentName
        {
            get { return _studentName; }
            set { _studentName = value; }
        }

        [DataMember]
        public int StudentAge
        {
            get { return _studentAge; }
            set { _studentAge = value; }
        }

        [DataMember]
        public bool StudentSex
        {
            get { return _StudentSex; }
            set { _StudentSex = value; }
        }
    }
    
    [DataContract]
    //由于Serialization是对数据的不同结构或形态的转化，在转化过程中必须预先知道两种数据相关的原数据（Metadata）。
    //原则上，只要知道.NET对象对应的Type,我们就可以通过反射（Reflection）的机制分析出该对象的结构。
    //在该例子中，Serializer要序列化School的对象,必须首先知道该对象所属的Type——这个Type通过构造函数传递给Serializer。
    //但是School定义了一个特殊的成员student，他属于我们的自定义Type，Serializer是不会识别这个对象的，
    //所以我们需要在定义DataContractOrder的时候运用KnownType Attribute来这个Type。
    [KnownType(typeof(Student))]
    public class School
    {
        private Guid _id;
        private DateTime _date;
        private Student _student;

        public School(Guid id, DateTime date, Student student)
        {
            this._id = id;
            this._date = date;
            this._student = student;
        }

        [DataMember]
        public Guid ID
        {
            get { return _id; }
            set { _id = value; }
        }

        [DataMember]
        public DateTime Date
        {
            get { return _date; }
            set { _date = value; }
        }

        [DataMember]
        public Student student
        {
            get { return _student; }
            set { _student = value; }
        }

        public override string ToString()
        {
            return string.Format("ID: {0}\ndate:{1}\nstudentid:{2}\nstudentname:{3}\nstudentsex:{4}",
                this._id, this._date, this._student.StudentID, this._student.StudentName,this._student.StudentSex);
        }
    }
}

       序列化和反序列化的方法

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;
using System.Xml.Serialization;
using System.IO;
using System.Xml;
using System.Diagnostics;

namespace WCFSerialization
{
    class Program
    {

        static string _basePath = @"E:\VS2008\";
        //序列化
        static void SerializeViaDataContractSerializer()
        {
            Student  stu = new Student (Guid.NewGuid(), "Dell",38, true);
            School sch = new School(Guid.NewGuid(), DateTime.Today, stu);
            string fileName = _basePath + "student.DataContractSerializer.xml";
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                DataContractSerializer serializer = new DataContractSerializer(typeof(School ));
                using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs))
                {
                    serializer.WriteObject(writer, sch);
                }
            }
            Process.Start(fileName);
        }
        //反序列化
        static void DeserializeViaDataContractSerializer()
        {
            School sch;
            string fileName = _basePath + "student.DataContractSerializer.xml";
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {
                DataContractSerializer serializer = new DataContractSerializer(typeof(School));
                using (XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas()))
                {
                    sch = serializer.ReadObject(reader) as School ;
                }
            }

            Console.WriteLine(sch);
            Console.Read();
        }


        static void Main(string[] args)
        {
            SerializeViaDataContractSerializer();
            DeserializeViaDataContractSerializer();
        }
    }
}

运行结果：

得出以下的Mapping关系：

1．        Root Element为对象的Type Name——DataContractOrder， Root Element可以通过DataContractAttribute中的Name参数定义。

2．        Type的Namespace会被加到XML根节点的Namespace中http://schemas.datacontract.org/2004/07/WCFSerialization ，Namespace可以通过DataContractAttribute中的NameSpace参数定义。

3．        对象的所有成员以XML Element的形式而不是以XML Attribute的形式输出。

4．        所有对象在XML的输出顺序是按照字母排序，出现的位置可以通过DataMemberAttribute的Order参数来定义。

5．        所有成员的Elelement 名称为成员名称，对应的Element的名称可以通过DataMemberAttribute中的Name定义。

6．        不论成员设置怎样的作用域（public,protected，internal，甚至市Private），所有运用了DataMemberAttribute的成员均被序列化到XML中。如果不希望某个成员输出到XML中，可以去掉成员对应的DataMemberAttribute Attribute。 此外DataMemberAttribute还有连个额外的参数：

       IsRequired：制定该成员为必须的，如果通过工具生成XSD的话，对应的Element的minOccur=“1”

       EmitDefaultValue：制定是否输入没有赋值的成员（值为默认值）是否出现在XML中

7．        Type和成员必须运用DataContractAttribute和DataMemberAttribute才能被序列化。

      Serialization的本质就是把.NETObject转化具有一定结构的XML Infoset。被序列化的成的XML Infoset记过Encoding被进一步转化成适合在网络上传递的字节流。当这些字节流从一个Application传递到另一个Application。由于程序的业务逻辑处理的是一个个的.NET对象，所以在目标Application, 会以一个相反的过程把接收到的字节流重构成为和原来一样的.NET Object——目标Application对接收到的字节流通过Decoding转化成XML Infoset，然后通过创建和用于序列化过程一致的Serializer通过Deserialization重建一个.NET Object。所以这就对Serializer提出了要求——它必须为Managed Type的结构和XML的结构提供可逆性的保证——我们把一个.NET Object序列化成一组XML，然后对这组XML进行反序列化重建的对象必须和原来一致。

 

参考资料：http://www.cnblogs.com/artech/archive/2007/03/10/669874.html