对象序列化

• .NET为对象序列化提供了俩个格式器，分别为：BinaryFormatter和SoapFormatter。
• 二进制序列化速度更快，序列化后数据较小。
• Soap序列化比前者唯一的优点就是平台无关性。
  下面就讲解下如何创建一个比较通用的序列化程序：
  

1.  对单个对象序列化，先定义一个接口，有两个泛型方法方法Serialize和Deserialize，分别完成序列化和反序列化，创建泛型方法是为了类型安全。
        public   interface  IGenericFormatter
       {
             // serializationStream:要序列化为的流。
           // graph:位于要序列化图形的根位置的对象。
            void  Serialize < T > (Stream serializationStream, T graph);
           T Deserialize < T > (Stream serializationStream); 
       }
2. 创建一个类GenericFormatter来实现这个接口。
        // U：实现IFormatter接口的类
        public   class  GenericFormatter < U >  : IGenericFormatter  where  U : IFormatter,  new ()
       {
            private  IFormatter m_formatter  =   new  U();
            #region  IGenericFormatter 成员
            public  T Deserialize < T > (System.IO.Stream serializationStream)
           {
                try
               {
                    return  (T)m_formatter.Deserialize(serializationStream);
               }
                catch
               {
                    throw ;
               }
           }
            public   void  Serialize < T > (System.IO.Stream serializationStream, T graph)
           {
               m_formatter.Serialize(serializationStream, graph);
           }
            #endregion
       }
3. 还可以将多个对象序列化到同一个流中，从一个流中反序列化出多个对象。为IGenericFormatter接口添加以下方法。
        public   interface  IGenericFormatter
       {
            void  Serialize < T > (Stream serializationStream, T graph,  params   object [] args);
            object [] Deserialize(Stream serializationStream);
            object [] Deserialize(Stream serializationStream,  int  count);
       }
4. 实现上边的方法。
        public   class  GenericFormatter < U >  : IGenericFormatter  where  U : IFormatter,  new ()
       {
            #region  IGenericFormatter 成员
            public   object [] Deserialize(System.IO.Stream serializationStream)
           {
                try
               {
                    return  Deserialize(serializationStream,  - 1 );
               }
                catch
               {
                    throw ;
               }
           }
           // count:要反序列化对象的个数，如果超出实际个数，将返回包含实际个数的对象数组
            public   object [] Deserialize(System.IO.Stream serializationStream,  int  count)
           {
               ArrayList result  =   new ArrayList();
                try
               {
                    for  ( int  i  =   0 ; count  <   0   ||  i  <  count; i ++ )
                   {
                       result.Add(Deserialize < object > (serializationStream));
                   }
               }
                catch  (XmlException) { }
                catch  {  throw ; }
                return  result.ToArray();
           }
            public   void  Serialize < T > (System.IO.Stream serializationStream, T graph,  params   object [] args)
           {
               Serialize(serializationStream, graph);
                foreach  (var item  in  args)
               {
                   Serialize(serializationStream, item);
               }
           }
            #endregion
       }
5. 单个对象序列化，反序列化实例。
      [Serializable]
        class  Program
       {
            static   void  Main( string [] args)
           {
               Program pro  =   new  Program();
               pro.Name  =   " ceshi1 " ;
               GenericFormatter < SoapFormatter >  soap  =   new  GenericFormatter < SoapFormatter > ();
               FileStream stream  =   new  FileStream( @" C:/FlashPast.xml " , FileMode.Create, FileAccess.ReadWrite);
               soap.Serialize(stream, pro);
                //  把流中位置归零。
               stream.Seek( 0 , System.IO.SeekOrigin.Begin);
               Program newPro  =  soap.Deserialize < Program > (stream);
               Console.ReadLine();
           }
            public   string  Name {  get ;  set ; }
       }
        // FlashPast.xml
   < SOAP - ENV:Envelope xmlns:xsi = " http://www.w3.org/2001/     XMLSchema-instance "  xmlns:xsd = " http://www.w3.org/2001/XMLSchema "  xmlns:SOAP - ENC = " http://schemas.xmlsoap.org/soap/encoding/ "  xmlns:SOAP - ENV = " http://schemas.xmlsoap.org/soap/envelope/ "  xmlns:clr = " http://schemas.microsoft.com/soap/encoding/clr/1.0 "  SOAP - ENV:encodingStyle = " http://schemas.xmlsoap.org/soap/encoding/ " >
   < SOAP - ENV:Body >
   < a1:Program id = " ref-1 "  xmlns:a1 = " http://schemas.microsoft.com/clr/nsassem/MyConsoleApplication/MyConsoleApplication%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull " >
   < _x003C_Name_x003E_k__BackingField id = " ref-3 " >
   ceshi1
   </ _x003C_Name_x003E_k__BackingField >
   </ a1:Program >
   </ SOAP - ENV:Body >
   </ SOAP - ENV:Envelope >
6. 多个对象序列化，反序列化实例。
       [Serializable]
        class  Program
       {
            static   void  Main( string [] args)
           {
               Program pro  =   new  Program();
               pro.Name  =   " ceshi1 " ;
               Program pro1  =   new  Program();
               pro1.Name  =   " ceshi2 " ;
               GenericFormatter < SoapFormatter >  soap  =   new  GenericFormatter < SoapFormatter > ();
               FileStream stream  =   new  FileStream( @" C:/FlashPast.xml " , FileMode.Create, FileAccess.ReadWrite);
               soap.Serialize(stream, pro, pro1);
                //  把流中位置归零。
               stream.Seek( 0 , System.IO.SeekOrigin.Begin);
                object [] arry  =  soap.Deserialize(stream);
               Console.ReadLine();
           }
            public   string  Name {  get ;  set ; }
       }