WCF分布式开发步步为赢(7):WCF数据契约与序列化

 [DataContract] // 数据契约属性声明
     class  MyDataContract
    {
        [DataMember(Name  =   " MyName " )] // 数据成员标记,支持别名定义
         public   string  Name
        {
             get ;
             set ;
        }
        [DataMember(Name  =   " MyEmail " )] // 数据成员标记,支持别名定义
         public  string  Email
        {
             get ;
             set ;
        }
        [DataMember] // 数据成员标记
         public   string  Mobile
        {
             get ;
             set ;
        }
         // 没有[DataMember]声明，不会被序列化
         public   string  Address
        {
             get ;
             set ;
        }
    }
}

public   abstract   class  XmlObjectSerializer
{
     //  Methods
     protected  XmlObjectSerializer()
    {
    }
     internal   static   void  CheckNull( object  obj,  string  name)
    {
         if  (obj  ==   null )
        {
             throw   new  ArgumentNullException(name);
        }
    }
     internal   virtual  Type GetSerializeType( object  graph)
    {
         if  (graph  !=   null )
        {
             return  graph.GetType();
        }
         return   null ;
    }
     private   static   string  GetTypeInfoError( int  errorMessage, Type type, Exception innerException)
    {
         string  str  =  (type  ==   null )  ?   string .Empty : SR.GetString( 1 ,  new   object [] { DataContract.GetClrTypeFullName(type) });
         string  str2  =  (innerException  ==   null )  ?   string .Empty : innerException.Message;
         return  SR.GetString(errorMessage,  new   object [] { str, str2 });
    }

     public   abstract   bool  IsStartObject(XmlDictionaryReader reader);
     public   virtual   bool  IsStartObject(XmlReader reader)
    {
        CheckNull(reader,  " reader " );
         return   this .IsStartObject(XmlDictionaryReader.CreateDictionaryReader(reader));
    }

     public   virtual   object  ReadObject(XmlDictionaryReader reader)
    {
         return   this .ReadObject(reader,  true );
    }
     public   virtual   object  ReadObject(XmlReader reader)
    {
        CheckNull(reader,  " reader " );
         return   this .ReadObject(XmlDictionaryReader.CreateDictionaryReader(reader));
    }
     public   abstract   object  ReadObject(XmlDictionaryReader reader,  bool  verifyObjectName);
     public   virtual   object  ReadObject(XmlReader reader,  bool  verifyObjectName)
    {
        CheckNull(reader,  " reader " );
         return   this .ReadObject(XmlDictionaryReader.CreateDictionaryReader(reader), verifyObjectName);
    }

     public   abstract   void  WriteEndObject(XmlDictionaryWriter writer);
     public   virtual   void  WriteEndObject(XmlWriter writer)
    {
        CheckNull(writer,  " writer " );
         this .WriteEndObject(XmlDictionaryWriter.CreateDictionaryWriter(writer));
    }
     public   virtual   void  WriteObject(XmlDictionaryWriter writer,  object  graph)
    {
        CheckNull(writer,  " writer " );
         try
        {
             this .WriteStartObject(writer, graph);
             this .WriteObjectContent(writer, graph);
             this .WriteEndObject(writer);
        }
         catch  (XmlException exception)
        {
             throw   new  SerializationException(GetTypeInfoError( 0 ,  this .GetSerializeType(graph), exception), exception);
        }
         catch  (FormatException exception2)
        {
             throw   new  SerializationException(GetTypeInfoError( 0 ,  this .GetSerializeType(graph), exception2), exception2);
        }
    }
     public   virtual   void  WriteObject(XmlWriter writer,  object  graph)
    {
        CheckNull(writer,  " writer " );
         this .WriteObject(XmlDictionaryWriter.CreateDictionaryWriter(writer), graph);
    }
     public   abstract   void  WriteObjectContent(XmlDictionaryWriter writer,  object  graph);
     public   virtual   void  WriteObjectContent(XmlWriter writer,  object  graph)
    {
        CheckNull(writer,  " writer " );
         this .WriteObjectContent(XmlDictionaryWriter.CreateDictionaryWriter(writer), graph);
    }
     public   abstract   void  WriteStartObject(XmlDictionaryWriter writer,  object  graph);
     public   virtual   void  WriteStartObject(XmlWriter writer,  object  graph)
    {
        CheckNull(writer,  " writer " );
         this .WriteStartObject(XmlDictionaryWriter.CreateDictionaryWriter(writer), graph);
    }
}

  [DataContract] // 数据契约属性声明
     class  UserDataContract
    {
        [DataMember(Name  =   " UserName " )] // 数据成员标记,支持别名定义
         public   string  Name
        {
             get ; set ;
        }
        [DataMember(Name  =   " UserEmail " )] // 数据成员标记,支持别名定义
         public  string  Email
        {
             get ; set ;
        }
        [DataMember] // 数据成员标记
         public   string  Mobile
        {
             get ; set ;
        }
         // 没有[DataMember]声明，不会被序列化
         public   string  Address
        {
             get ;  set ;
        }
    }

  // 1.服务契约
    [ServiceContract(Namespace  =   " http://www.cnblogs.com/frank_xl/ " )]
     public   interface  IWCFService
    {
         // 操作契约
        [OperationContract]
         bool  AddNewUser(UserDataContract user);
         // 操作契约
        [OperationContract]
        UserDataContract GetUserByName( string  name);
    }
     // 2.服务类，继承接口。实现契约
     public   class  WCFService : IWCFService
    {
         // 实现接口定义的方法
         public   bool  AddNewUser(UserDataContract user)
        {
             // 这里可以定义数据持久化操作，访问数据库等
             // 不给出具体代码
            Console.WriteLine( " Hello! ,This an DataContract demo for WCF Service  " );
             return   true ;
        }
         // 实现接口定义的方法
         public  UserDataContract GetUserByName( string  name)
        {
            UserDataContract userDataContract  =   new  UserDataContract();
            userDataContract.Address  =   " ShangHai China " ;
            userDataContract.Email  =   " frank_xl@163.com " ;
            userDataContract.Name  =   " Frank Xu Lei " ;
            Console.WriteLine( " Hello! {0},This an overloading demo WCF Service  " , name);
             return  userDataContract;
        }
    }
   

  class  WCFClient
    {
         static   void  Main( string [] args)
        {
             // 实例化客户端服务代理Tcp
            WCFServiceClient wcfServiceProxy  =
                 new  WCFServiceClient( " WCFDataContractFormatting.IWCFService " );
            Console.WriteLine( " Test call service using TCP--------------------. " );
             // 通过代理调用服务，分别传递不同的参数，进行测试
             // 实例化数据契约对象，设置信息
            UserDataContract userDataContract  =   new  UserDataContract();
            userDataContract.UserName  =   " WCF Client: Frank Xu Lei " ;
            userDataContract.UserEmail  =   " WCF Client: frank_xl@163.com  " ;
            userDataContract.Mobile  =   " WCF Client:1666666666 " ;
             // 调用代理服务，增加用户操作：
            wcfServiceProxy.AddNewUser(userDataContract);

             // 查询用户信息：
             string  name  =   " WCF Client: Frank Xu " ;
            UserDataContract userData  =  wcfServiceProxy.GetUserByName(name);
             if  (userData  !=   null )
            {
                Console.WriteLine(userData.UserName);
                Console.WriteLine(userData.UserEmail);
                Console.WriteLine(userData.Mobile);
            }

             // Debuging
            Console.WriteLine( " Press any key to continue " );
            Console.Read();

        }
    }
}