.Net中的各種序列化

我們知道將對象的狀態保持在存儲媒體中，以便可以在以后重新創建精確的副本這正是數據持久化所要做的。而且，不同應用程序之間的通訊需要相互傳輸數據。那么序列化和反序列化正是為此而生。

序列化和反序列化

所謂序列化就是把對象轉換為字節序列的過程稱為對象的序列化。

所謂反序列化就是字節序列恢復為對象的過程稱為對象的反序列化

那么.net開發中都為我們提供了哪些序列化和反序列化的方式呢?我簡單總結了一下，有以下幾種：

1.位於System.Xml.Serialization命名空間下的XmlSerializer

2.位於System.Runtime.Serialization.Formatters.Soap命名空間下的SoapFormatter

3.位於System.Runtime.Serialization.Formatters.Binary;命名空間下的BinaryFormatter

4.位於System.Web.Script.Serialization命名空間下的JavaScriptSerializer

5.位於System.Runtime.Serialization.Json命名空間下的DataContractJsonSerializer、DataContractSerializer

6.位於System.Runtime.Serialization命名空間下的NetDataContractSerializer

7.來自第三方的Newtonsoft.Json

那么我簡單地寫了個序列化幫助類。完整代碼如下(它們都有各自的使用場合,用法也不止如此)：

namespace Serialization
{
    using System.IO;
    using System.Runtime.Serialization;
    using System.Runtime.Serialization.Formatters.Binary;
    using System.Runtime.Serialization.Formatters.Soap;
    using System.Runtime.Serialization.Json;
    using System.Text;
    using System.Web.Script.Serialization;
    using System.Xml.Serialization;
    using Newtonsoft.Json;
    public class SerializeHelper
    {
        #region XmlSerializer
        public static void XmlSerialize(string fileName, object obj)
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                try
                {
                    XmlSerializer serializer = new XmlSerializer(obj.GetType());
                    serializer.Serialize(fs, obj);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }

        public static T XmlDeSerialize<T>(string fileName) where T : class,new()
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                try
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(T));
                    return serializer.Deserialize(fs) as T;
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }
        #endregion

        #region SoapFormatter
        //不支持泛型 所序列化的類型必須標志為Serializable
        public static void SoapSerialize(string fileName, object obj)
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                try
                {
                    SoapFormatter formatter = new SoapFormatter();
                    formatter.Serialize(fs, obj);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }

        public static T SoapDeSerialize<T>(string fileName) where T : class, new()
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                try
                {
                    SoapFormatter formatter = new SoapFormatter();
                    return formatter.Deserialize(fs) as T;
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }
        #endregion

        #region BinaryFormatter
        //所序列化的類型必須標志為Serializable
        public static void BinarySerialize(string fileName, object obj)
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                try
                {
                    BinaryFormatter formatter = new BinaryFormatter();
                    formatter.Serialize(fs, obj);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }

        public static T BinaryDeSerialize<T>(string fileName) where T : class, new()
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                try
                {
                    BinaryFormatter formatter = new BinaryFormatter();
                    return formatter.Deserialize(fs) as T;
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }
        #endregion

        #region JavaScriptSerializer
        public static string JavaScriptSerialize(object obj)
        {
            JavaScriptSerializer serizlizer = new JavaScriptSerializer();
            return serizlizer.Serialize(obj);
        }

        public static T JavaScriptDeSerialize<T>(string json) where T : class, new()
        {
            JavaScriptSerializer serizlizer = new JavaScriptSerializer();
            return serizlizer.Deserialize<T>(json);
        }
        #endregion

        #region DataContractJsonSerializer
        /// <summary>
        /// (DataContractJsonSerialize)序列化
        /// </summary>
        /// <param name="item">對象</param>
        public static string DataContractJsonSerialize(object obj)
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
            using (MemoryStream ms = new MemoryStream())
            {
                serializer.WriteObject(ms, obj);
                return Encoding.UTF8.GetString(ms.ToArray());
            }
        }

        /// <summary>
        /// (DataContractJsonSerialize)反序列化
        /// </summary>
        /// <param name="str">字符串序列</param>
        public static T DataContractJsonDeSerialize<T>(string str) where T : class,new()
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
            using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(str)))
            {
                return serializer.ReadObject(ms) as T;
            }
        }
        #endregion

        #region NetDataContractSerializer
        public static void NetDataContractSerialize(string fileName, object obj)
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                try
                {
                    NetDataContractSerializer serializer = new NetDataContractSerializer();
                    serializer.Serialize(fs, obj);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }

        public static T NetDataContractDeSerialize<T>(string fileName) where T : class,new()
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                try
                {
                    NetDataContractSerializer serializer = new NetDataContractSerializer();
                    return serializer.Deserialize(fs) as T;
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }
        #endregion

        #region DataContractSerializer
        public static void DataContractSerialize(string fileName, object obj)
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                try
                {
                    DataContractSerializer serializer = new DataContractSerializer(obj.GetType());
                    serializer.WriteObject(fs, obj);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }

        public static T DataContractDeSerialize<T>(string fileName) where T : class,new()
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                try
                {
                    DataContractSerializer serializer = new DataContractSerializer(typeof(T));
                    return serializer.ReadObject(fs) as T;
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }
        #endregion

        #region Newtonsoft
        public static string JsonConvertSerialize(object item)
        {
            return JsonConvert.SerializeObject(item);
        }

        public static T JsonDeSerialize<T>(string json) where T : class,new()
        {
            return JsonConvert.DeserializeObject<T>(json);
        }
        #endregion
    }
}

 關於各種序列化的各自"用武之地"以及總體性能比較，有空再細細深究。