zoukankan      html  css  js  c++  java

  • WCF 第六章 序列化和编码 使用IExtensibleDataObject 的双向序列化

    对支持面向服务的架构来说，数据契约版本化会随着时间推移称为面向服务的一个重要方面。 随着时间推移，比如创建了新的服务，它生成了一个数据契约的新版本，通过添加额外的信息。而不是重编译所有之前使用老的数据契约版本的客户端和服务端，你 可能希望它们可以平滑的升级以便于可以共享公共数据，这也正是DataContractSerializer 要做的事情。如果有额外的数据，DataContractSerializer 将会抛弃额外的信息。但这并不是在所有情况下都能正常工作。如果数据被接受后又发送回给客户端，忽略任何额外数据意味着可能会丢失信息。一个例子是一个新 的客户端发送数据给一个将信息存储在一个数据库中以用来在未来的某个时刻访问的旧服务。在这种情况下，如果客户端发送给服务端过程中有任何额外信息，它将 在数据发送回给客户端时丢失。这也是IExentsibleDataObject接口要解决的问题。它提供一个接口给不知道数据契约的外部数据。它通过将 反序列化过程中的未知数据存储到一个ExtensibleDataObject类中实现的。

      DataContractSerializer默认行为就是忽略任何未知数据，除非IExentsibleDataObject接口在契约上实现。这里有 一个在一个Employee类上使用的两个数据契约。第一个在列表6.21中显示的数据契约有三个字段: FirstName, LastName和EmployeeId.第二个在列表6.22中显示的数据契约是第一个数据契约新版本，它添加了一个额外字段，SSN。

    提示 确定实现了IExentsibleDataObject

    可以不通过使用svcutil.exe或者添加服务引用来共享你的数据契约。这是通过向包含你的数据契约的程序集添加一个引用实现的。在这种情况相爱，确定数据契约实现了IExtensibleDataObject或者它们不支持回环序列化。

    列表6.21 初始的Employee 契约

    01using System.Runtime.Serialization;
    02 
    03namespace EssentialWCF
    04{
    05    [DataContract]
    06    public class Employee
    07    {
    08        private int employeeID;
    09        private string firstName;
    10        private string lastName;
    11 
    12        public Employee()
    13        {
    14        }
    15 
    16        public Employee(int employeeID, string firstName, string lastName)
    17        {
    18            this.employeeID = employeeID;
    19            this.firstName = firstName;
    20            this.lastName = lastName;
    21        }
    22 
    23        [DataMember]
    24        public int EmployeeID
    25        {
    26            get { return employeeID; }
    27            set { employeeID = value; }
    28        }
    29 
    30        [DataMember]
    31        public string FirstName
    32        {
    33            get { return firstName; }
    34            set { firstName = value; }
    35        }
    36 
    37        [DataMember]
    38        public string LastName
    39        {
    40            get { return lastName; }
    41            set { lastName = value; }
    42        }
    43    }
    44}

      列表6.22显示了Employee契约的一个包含了一个额外字段SSN的新版本，它实现了employee的社会安全账号。

    列表6.22 新的Employee契约

    01using System.Runtime.Serialization;
    02 
    03namespace EssentialWCF
    04{
    05    [DataContract]
    06    public class Employee
    07    {
    08        private int employeeID;
    09        private string firstName;
    10        private string lastName;
    11        private string ssn;
    12 
    13        public Employee()
    14        {
    15        }
    16 
    17        public Employee(int employeeID, string firstName, string lastName, string ssn)
    18        {
    19            this.employeeID = employeeID;
    20            this.firstName = firstName;
    21            this.lastName = lastName;
    22            this.ssn = ssn;
    23        }
    24 
    25        [DataMember]
    26        public int EmployeeID
    27        {
    28            get { return employeeID; }
    29            set { employeeID = value; }
    30        }
    31 
    32        [DataMember]
    33        public string FirstName
    34        {
    35            get { return firstName; }
    36            set { firstName = value; }
    37        }
    38 
    39        [DataMember]
    40        public string LastName
    41        {
    42            get { return lastName; }
    43            set { lastName = value; }
    44        }
    45 
    46 
    47        [DataMember]
    48        public string SSN
    49        {
    50            get { return ssn; }
    51            set { ssn = value; }
    52        }
    53    }
    54}

    列表6.21和列表6.22中的数据契约是不同的。你可能会认为使用原来数据契约的服务奖不会接受使用一个新的数据契约的客户端的通信请求。事实 上，所有事情都工作的很好。原因是新数据契约中的所有字段都在原始数据契约中存在。这意味着服务端需要的所有信息都存在。这个时候发生的就是服务端忽略掉 额外的数据。这可以通过下面列表6.23中显示的UpdateEmployee服务显示出来。服务生成了一个Employee实例，做一些额外的工作，然 后把同样的Employee实例返回给客户端。

    列表6.23 Employee更新服务

    01using System.ServiceModel;
    02 
    03namespace EssentialWCF
    04{
    05    [ServiceContract]
    06    public interface IEmployeeInformation
    07    {
    08        [OperationContract]
    09        Employee UpdateEmployee(Employee employee);
    10    }
    11    public class EmployeeInformation : IEmployeeInformation
    12    {
    13        public EmployeeInformation()
    14        {
    15        }
    16        public Employee UpdateEmployee(Employee emp)
    17        {
    18            //Pretend to do something here...
    19            //Not really important for this demo.
    20 
    21            //We return the employee instance back to the client.
    22            return emp;
    23        }
    24    }
    25}

      相应的客户端代码在列表6.24显示

    列表6.24 Employee更新客户端

    01namespace Client
    02{
    03    class Program
    04    {
    05        static void Main(string[] args)
    06        {
    07            Employee e = new Employee() { EmployeeID = 123456, FirstName = "Daniel", LastName = "Dong", SSN = "000-00-0000" };
    08            Console.WriteLine("{0} {1}, {2}, {3}", new object[]{e.FirstName, e.LastName, e.EmployeeID, e.SSN});
    09            using (EmployeeInformationClient client = new EmployeeInformationClient())
    10            {
    11                e = client.UpdateEmployee(e);
    12            }
    13            Console.WriteLine("{0} {1}, {2}, {3}", new object[] { e.FirstName, e.LastName, e.EmployeeID, e.SSN });
    14            Console.WriteLine("Press [ENTER] to exit.");
    15            Console.ReadLine();
    16        }
    17    }
    18}

      服务端返回的结果中不包含SSN字段。这意味着由于数据契约版本不兼容导致我们不可以发送我们的数据契约到服务端并返回。所以如何才能修改我们的服务使其 接受未知数据并恰当的返回？幸运的是，WCF提供了一个方法来接收并存储未知数据。我们可以改变我们的服务端的数据契约来允许它不了解的额外的数据。为了 实现这个你必须在数据契约上实现IExtensibleDataObject接口，默认是通过svcutil.exe或者添加服务引用在生成客户端代理时 完成的。列表6.25显示了支持IExtensibleDataObject接口的初始Employee契约。

    列表6.25 使用IExentsibleDataObject的初始数据契约

    01using System.Runtime.Serialization;
    02 
    03namespace EssentialWCF
    04{
    05    [DataContract]
    06    public class Employee : IExtensibleDataObject
    07    {
    08        private ExtensionDataObject extensionData;
    09        private int employeeID;
    10        private string firstName;
    11        private string lastName;
    12 
    13        public Employee()
    14        {
    15        }
    16 
    17        public Employee(int employeeID, string firstName, string lastName)
    18        {
    19            this.employeeID = employeeID;
    20            this.firstName = firstName;
    21            this.lastName = lastName;
    22        }
    23 
    24        [DataMember]
    25        public int EmployeeID
    26        {
    27            get { return employeeID; }
    28            set { employeeID = value; }
    29        }
    30 
    31        [DataMember]
    32        public string FirstName
    33        {
    34            get { return firstName; }
    35            set { firstName = value; }
    36        }
    37 
    38        [DataMember]
    39        public string LastName
    40        {
    41            get { return lastName; }
    42            set { lastName = value; }
    43        }
    44 
    45        #region IExtensibleDataObject Members
    46 
    47        public ExtensionDataObject ExtensionData
    48        {
    49            get
    50            {
    51                return extensionData;
    52            }
    53            set
    54            {
    55                extensionData = value;
    56            }
    57        }
    58 
    59        #endregion
    60    }
    61}

    通过这个改变现在客户端可以从服务端接收SSN成员。假设这个行为是在一个面向服务架构中期望的结果，你可能为了最佳实践在所有的数据契约上实现IExtensibleDataObject接口。


    =======
    转载自
    作者：DanielWise
    出处：http://www.cnblogs.com/danielWise/
     
  • 相关阅读:
    python入门-数据类型
    jmeter进行简单性能测试
    Charles抓包工具
    jemter分布式部署及linux下分布式脚本执行
    Java-List
    重载
    static关键字
    pycharm问题
    charles安装使用及问题
    安装pipenv
  • 原文地址：https://www.cnblogs.com/llbofchina/p/2094158.html
Copyright © 2011-2022 走看看