重温WCF之数据契约和序列化（四）

一、数据契约

1.使用数据协定可以灵活控制哪些成员应该被客户端识别。

    [DataContract]

    public class Employee

    {

        [DataMember]

        public string Name { get; set; }

        [DataMember]

        public int Age { get; set; }

        [DataMember]

        public string City { get; set; }

    }

    

    [ServiceContract]

    public interface IService

    {

        [OperationContract]

        Employee GetAEmployee();

    }



    public class MyService : IService

    {

        public Employee GetAEmployee()

        {

            return new Employee { Name = "小朋友", Age = 32 };

        }

    }

    class Program

    {

       static void Main(string[] args)

        {

            using (ServiceHost host = new ServiceHost(typeof(Service1)))

            {

                host.AddServiceEndpoint(typeof(IService1), new WSHttpBinding(), "http://127.0.0.1:8888/service1");

                ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();

                behavior.HttpGetEnabled = true;

                behavior.HttpGetUrl = new Uri("http://127.0.0.1:8888/service");  //httpGetUrl客户端引用的地址

                host.Description.Behaviors.Add(behavior);

                host.Opened += delegate

                {

                    Console.WriteLine("服务已启动");

                    Console.ReadKey();

                };

                host.Open();

            }

        }

    }

如果把Employee类中的某个成员的DataMember属性去掉，则在客户端代理类中就不会生成该属性

2.数据协定也有隐藏真实身份的作用

    [DataContract(Name = "Worker")]

    public class Employee

    {

        [DataMember(Name = "Worker_Name")]

        public string Name { get; set; }



        [DataMember(Name = "Worker_Age")]

        public int Age { get; set; }



        [DataMember(Name = "Worker_City")]

        public string City { get; set; }

    }

这样在客户端生成的代理类的成员名称就和服务器端不一样

3.（已知类型），在一些比较复杂的类型无法反序列化（不能识别类型）的时候，就得考虑使用KnownTypeAttribute来标注可能涉及到的外部类型，但如果遇到像泛型这些较为复杂的类型，就要考虑在带数据协定的类中添加一个静态方法，该方法返回Type 的IEnumerable，一般是Type[]就可以了，而在KnownTypeAttribute的构造函数中使用这个方法的名字。

[DataContract]

    [KnownType("GetKnowTypes")]

    public class Student

    {

        [DataMember]

        public string Name;

        [DataMember]

        public string Phone;

        [DataMember]

        public AddrInfo Address;

        [DataMember]

        public object Scores;



        static Type[] GetKnowTypes()

        {

            return new Type[] { typeof(Dictionary<string,float>) };

        }

    }

    [DataContract]

    public class AddrInfo

    {

        [DataMember]

        public string Province;

        [DataMember]

        public string City;

        [DataMember]

        public string DetailAddr;

    }

      public class MyService : IService

    {

        public Student GetStudentInfo()

        {

            Student stu = new Student();

            AddrInfo info = new AddrInfo();

            info.Province = "广东省";

            info.City = "佛山市";

            info.DetailAddr = "火星路-300号";

            stu.Name = "小陈";

            stu.Phone = "1388888888";

            stu.Address = info;

            Dictionary<string, float> m_scores = new Dictionary<string, float>();

            m_scores.Add("语文", 97f);

            m_scores.Add("英语", 64.5f);

            m_scores.Add("数学", 38f);

            m_scores.Add("历史", 77.6f);

            m_scores.Add("地理", 82.3f);

            stu.Scores = m_scores;

            return stu;

        }

    }

 static void Main(string[] args)

        {

            using (ServiceHost host = new ServiceHost(typeof(Service1)))

            {

                host.AddServiceEndpoint(typeof(IService1), new WSHttpBinding(), "http://127.0.0.1:8888/service1");

                ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();

                behavior.HttpGetEnabled = true;

                behavior.HttpGetUrl = new Uri("http://127.0.0.1:8888/service");  //httpGetUrl客户端引用的地址

                host.Description.Behaviors.Add(behavior);

                host.Opened += delegate

                {

                    Console.WriteLine("服务已启动");

                    Console.ReadKey();

                };

                host.Open();

            }

        }





        static void Main(string[] args)

        {

            WS.ServiceClient cli = new WS.ServiceClient();

            WS.Student stu = cli.GetStudentInfo();

            string msg = "学生姓名：{0}\n联系电话：{1}\n" +

                        "地址信息：-----------\n" +

                        "省份：{2}\n" +

                        "市区：{3}\n" +

                        "详细地址：{4}";

            Console.WriteLine(msg, stu.Name, stu.Phone, stu.Address.Province, stu.Address.City, stu.Address.DetailAddr);

            Console.WriteLine("---------------------------------------");

            Console.WriteLine("学生成绩单：");

            Dictionary<string, float> scores = stu.Scores as Dictionary<string, float>;

            foreach (var item in scores)

            {

                Console.Write("{0}：{1}\n", item.Key, item.Value);

            }



            Console.ReadKey();

        }

使用[ServiceKnownType(typeof(Order))]放在服务契约上，使用[KnownType(typeof(Order))]放在数据契约上

[ServiceContract]

    [ServiceKnownType(typeof(Order))]//可以放到这里

    public interface IService1

    {

        [OperationContract]

        //[ServiceKnownType(typeof(Order))]也可以放到这里

        void AddOrder(OrderBase order);

    }

    [DataContract]

   // [KnownType(typeof(Order))]也可以放到这里

    public abstract class OrderBase

    {

        [DataMember]

        public Guid ID { get; set; }



        [DataMember]

        public DateTime Date { get; set; }



        [DataMember]

        public string Customer { get; set; }



        [DataMember]

        public string ShipAddress { get; set; }

    }

    [DataContract]

    public class Order : OrderBase

    {

        [DataMember]

        public double TotalPrice { get; set; }

    }



    public class Service1 : IService1

    {

        public void AddOrder(OrderBase order)

        {

            Console.WriteLine(order.Customer);

        }

    }



    public class Program

    {

        static void Main(string[] args)

        {

            using (Service1Client client = new Service1Client())

            {

                Order order = new Order() { Customer = "yxl" };

                client.AddOrder(order);



            }

            Console.ReadKey();

        }

    }

如果不标识ServiceKnownType或KnownType，客户端将不会生成Order类

二、序列化

1.NET序列化机制

 　　在.NET Framework 3.0之前，提供了3中序列化器，序列化器理解为把可序列化的类型序列化成XML的类。这三种序列化器分别是BinaryFormatter、SoapFormatter和XmlSerializer类。下面分别介绍下这3种序列化器。

• BinaryFormatter类：把.NET Object序列化成二进制格式。在这个过程，对象的公共字段和私有字段以及类名称（包括类的程序集名），将转换成成字节流。
• SoapFormatter类：把.NET Object序列化成SOAP格式，SOAP是一种轻量、简单的，基于XML的协议。只序列化字段，包括公共字段和私有字段。
• XmlSerializer类：该类仅仅序列化公共字段和属性，且不保存类型的保真度。

　　对于这三种序列化机制，BinaryFormatter二进制序列化的优点是：性能高，但是不能跨平台。而SoapFormatter，XmlSerializer的优点是：跨平台、互操作性好，并且可读性强，但是传输性能不及BinaryFormatter。

原有的格式化器需要将类型的程序集及版本控制信息持久化到流中，以保证对象被反序列化为正确的类型，这种方式一定程度上妨碍面向服务交互。原因如下：BinaryFormatter和SoapFormatter具备类型保真，它们要求其所在程序集、版本等信息必须完全一致，如果不同则视为是不同类型的对象，这就要求客户端必须拥有原有的.NET 程序集。面向服务的交互方式应该更倾向于平台无关，并最大限度的解耦，因此这2个格式化器显然与WCF有些不搭。再看XmlSerializer格式化器，在功能上与DataContractSerializer格式器类似，但是为何没有使用XmlSerializer格式器而是引人新格式器，我的理解如下：在SOA服务的构建过程中，提倡契约优先的构建原则，也就是说我们应该优先构建契约后构建具体的代码，在构建过程中并不考虑其具体的序列化过程。（契约优先相对于代码优先在设计层面具有更高的抽象程度，降低了服务设计与平台的耦合度，因此我更倾向于契约优先的开发顺序。）此外，XmlSerializer为如何将数据表示成XML提供了精确的控制，DataContractSerializer则提供了较少的控制，所以DataContractSerializer的序列化过程是可预知的，容易优化，所以它与XmlSerializer相比有更好的性能（我查到的数字是提升了约10%）。　　

2.WCF中序列化机制

在WCF中，提供了专门用来序列化和反序列操作的类，该类就是DataContractSerializer类。一般而言，WCF会自动选择使用DataContractSerializer来对可序列话数据契约进行序列化，不需要开发者直接调用。WCF除了支持DataContractSerializer类来进行序列化外，还支持另外两种序列化器，这两种序列化器分别为：XMLSerializer（定义在System.XML.Serialization namespace）和NetDataContractSerializer (定义在System.XML.Serialization namespace)。XmlSerializer类不是WCF专用的类，Asp.net Web服务统一使用该类作为序列化器，但XmlSerializer类支持的类少于DataContractSerializer列支持的类型，但它允许对生成的XML进行更多的控制，并且支持更多的XML架构定义语言（XSD）标准。它不需要在可序列化类上有任何声明性的属性。

　　默认情况下，WCF 使用 DataContractSerializer 类来序列化数据类型。 此序列化程序支持下列类型：

• 基元类型（如：整数、字符串和字节数组）以及某些特殊类型（如 XmlElement 和 DateTime）。
• 数据协定类型（用 DataContractAttribute 属性标记的类型）。
• 用 SerializableAttribute 属性标记的类型，包括实现 ISerializable 接口的类型。
• 实现 IXmlSerializable 接口的类型。
• 许多常见集合类型，包括许多泛型集合类型。

　　DataContractSerializer类与NetDataContractSerializer类类似，它们之间主要的区别在于：在使用NetDataContractSerializer进行序列化时，不需要指定序列化的类型，如：

NetDataContractSerializer serializer =

    new NetDataContractSerializer();  // 不需要明确指定序列化的类型

serializer.WriteObject(writer, p);



// 而使用DataContractSerializer需要明确指定序列化的类型

DataContractSerializer serializer =

            new DataContractSerializer(typeof(Order)); // 需要明确指定序列化的类型

        serializer.WriteObject(writer, p);

SerializableAttribute与DataContract异同。

相同点：都是标记类型为可序列化类型

不同点：在于序列化的成员不一样，DataContract是Opt-in(明确参与)的方式，即使用DataMember特性明确标识哪些成员需要序列化，而Serializable是Opt-out方式，即使用NoSerializable特性明确标识不参与序列化的成员。

我个人意见，DataContractSerializable就用在它应该用的地方吧，如果不是用WCF，还是不要用它了，它的序列化结果有一些微软专属的东西。对于来自网络的松散Xml接口数据，XmlSerializer是不二之选。如果想把对象完整地保存下来（数据与状态），同时又不需要被人看。那就用BinaryFormatter吧，SerializableAttribute默认是使用BinaryFormatter序列化的。