【.NET】编程备忘：.Net中的各种序列化

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
    }
}