C#序列化和反序列化代码-CSDN博客

我们在日常开发中会经常用到序列化和反序列化，他们到底是什么意思呢？通俗的讲序列化就是把对象转化成数据文件或者字段（二进制或者XML），反序列化就是数据文件或者字段转化为数据对象。下面我以提问题的方式，帮大家解释一下序列化和反序列化。（C#代码为例）
一、为什么使用序列化和反序列化?
　　1.保存对象。通常我们在C#代码中构建了一个对象需要把该对象保存到数据库、文件、Application、Session、Coockie、ViewState等其他存储环境中，以备下次直接使用。
　　2.共享数据. 对象仅在创建对象的应用程序域中有效，其他应用程序域想调用该对象数据就会使用该技术。
　　3.在网络上传送对象的字节序列。其中Web Service就是一个典型的例证。
　　4.在一些分布式系统中也经常会用到该技术。
二、序列化和反序列化有哪些类型？
　　在C#中序列化反序列化类型大致有如下三种：
　　　　第一、二进制数据（BinaryFormatter->IFormatter）
　　　　第二、XML数据（XmlSerializer）
　　　　第三、Soap数据（SoapFormatter->IFormatter）
三、序列化和反序列化分别如何实现？　　
共用类（UserInFo）

/// <summary>
/// UserInfo for public test smaple
/// </summary>
[Serializable]
public class UserInfo
{
    #region Database fields
    private System.Int32 _UserID;
    private System.String _UserName;
    private System.Int16 _UserType;
    private System.String _Email;
    private System.String _Pwd;
    private System.String _Firstname;
    private System.String _Lastname;
    #endregion
    #region GETs and SETs
    public System.Int32 UserID
     {
        get { return _UserID; }
        set { _UserID = value; }
     }
    public System.String UserName
     {
        get { return _UserName; }
        set { _UserName = value; }
     }
    public System.Int16 UserType
     {
        get { return _UserType; }
        set { _UserType = value; }
     }
    public System.String Email
     {
        get { return _Email; }
        set { _Email = value; }
     }
    public System.String Pwd
     {
        get { return _Pwd; }
        set { _Pwd = value; }
     }
    public System.String Firstname
     {
        get { return _Firstname; }
        set { _Firstname = value; }
     }
    public System.String Lastname
     {
        get { return _Lastname; }
        set { _Lastname = value; }
     }
    #endregion
    public UserInfo()
     {
     }
}

第一、二进制数据　　　　　　　　
序列化二进制代码

public static byte[] Serialize(UserInfo usr)
     {
         IFormatter formatter = new BinaryFormatter();
         MemoryStream ms = new MemoryStream();
        byte[] b;
         formatter.Serialize(ms, usr);
         ms.Position = 0;
         b = new byte[ms.Length];
         ms.Read(b, 0, b.Length);
         ms.Close();
        return b;
     }

反序列化二进制代码

public static UserInfo Deserialize(byte[] byteArray)
     {
         IFormatter formatter = new BinaryFormatter();
         MemoryStream ms = new MemoryStream();
         ms.Write(byteArray, 0, byteArray.Length);
         ms.Position = 0;
         UserInfo usr = formatter.Deserialize(ms) as UserInfo;
        return usr;

     }

第二、Xml数据

序列化XML代码

  public static XmlDocument Serialize(UserInfo usr)
     {
         XmlSerializer lizer = new XmlSerializer(usr.GetType());
         MemoryStream ms = new MemoryStream();
         lizer.Serialize(ms, usr);
         XmlDocument doc=new XmlDocument();
         doc.Load(ms);
        return doc;
     }

反序列化XML代码

  public static UserInfo DeserializeXml(XmlDocument doc)
     {
         XmlSerializer lizer = new XmlSerializer(typeof(UserInfo));
         StringReader reader = new StringReader(doc.OuterXml);
         UserInfo usr = lizer.Deserialize(reader) as UserInfo;
        return usr;
     }

第三、Soap数据
序列化代码

static void Serialize() 
     {
        // Create a hashtable of values that will eventually be serialized.
         Hashtable addresses = new Hashtable();
         addresses.Add("Jeff", "123 Main Street, Redmond, WA 98052");
         addresses.Add("Fred", "987 Pine Road, Phila., PA 19116");
         addresses.Add("Mary", "PO Box 112233, Palo Alto, CA 94301");
        // To serialize the hashtable (and its key/value pairs), 
        // you must first open a stream for writing.
        // Use a file stream here.
         FileStream fs = new FileStream("DataFile.soap", FileMode.Create);
        // Construct a SoapFormatter and use it 
        // to serialize the data to the stream.
         SoapFormatter formatter = new SoapFormatter();
        try 
         {
             formatter.Serialize(fs, addresses);
         }
        catch (SerializationException e) 
         {
             Console.WriteLine("Failed to serialize. Reason: " + e.Message);
            throw;
         }
        finally 
         {
             fs.Close();
         }
     }

反序列化代码

static void Deserialize() 
     {
        // Declare the hashtable reference.
         Hashtable addresses  = null;
        // Open the file containing the data that you want to deserialize.
         FileStream fs = new FileStream("DataFile.soap", FileMode.Open);
        try 
         {
             SoapFormatter formatter = new SoapFormatter();
            // Deserialize the hashtable from the file and 
            // assign the reference to the local variable.
             addresses = (Hashtable) formatter.Deserialize(fs);
         }
        catch (SerializationException e) 
         {
             Console.WriteLine("Failed to deserialize. Reason: " + e.Message);
            throw;
         }
        finally 
         {
             fs.Close();
         }
        // To prove that the table deserialized correctly, 
        // display the key/value pairs to the console.
        foreach (DictionaryEntry de in addresses) 
         {

             Console.WriteLine("{0} lives at {1}.", de.Key, de.Value);
          }
}