SerializableHelper序列化和反序列化工具类

using System;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

    /// <summary>

    /// 序列化和反序列化工具类SerializableHelper
    /// </summary>
    public static class SerializableHelper
    {




        #region SOAP序列化- 将对象以XML形式进行序列化并传输，完全保留对象数据与状态。
        /// <summary>
        /// SOAP序列化
        /// </summary>
        /// <param name="Obj">对象</param>
        /// <returns></returns>
        public static string SoapSerializable(object Obj)
        {
            string Rsult = string.Empty;
            try
            {
                IFormatter Formatter = new SoapFormatter();
                Stream MS = new MemoryStream();
                Formatter.Serialize(MS, Obj);
                byte[] B = new byte[MS.Length];
                MS.Position = 0;
                MS.Read(B, 0, B.Length);
                Rsult = Convert.ToBase64String(B);
                MS.Close();
                MS.Dispose();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return Rsult;
        }


        /// <summary>
        /// SOAP反序列化
        /// </summary>
        /// <param name="Str">序列化的字符</param>
        /// <returns></returns>
        public static T SoapDeserialize<T>(string Str) where T : class
        {
            T Result = null;
            try
            {
                IFormatter Formatter = new SoapFormatter();
                byte[] B = Convert.FromBase64String(Str);
                Stream MS = new MemoryStream(B);
                Result = Formatter.Deserialize(MS) as T;
                MS.Close();
                MS.Dispose();
            }
            catch (Exception)
            {
                
                return null;
            }
            return Result;
        }


        #endregion


        #region Binary二进制序列化
        /// <summary>
        /// 二进制序列化
        /// </summary>
        /// <param name="obj">对象</param>
        /// <returns></returns>
        public static string BinarySerialize(object obj)
        {
            string result = default(string);
            if (obj != null)
            {
                try
                {
                    BinaryFormatter formatter = new BinaryFormatter();
                    MemoryStream stream = new MemoryStream();
                    formatter.Serialize(stream, obj);
                    result = Encoding.Unicode.GetString(stream.GetBuffer());
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            return result;




        }






        /// <summary>
        /// 二进制序列化对象
        /// </summary>
        /// <param name="str">对象</param>
        /// <returns></returns>
        public static T BinaryDeserialize<T>(string str) where T : class
        {
            T result = null;
            if (str.Length > 0)
            {
                try
                {
                    BinaryFormatter formatter = new BinaryFormatter();
                    MemoryStream stream = new MemoryStream(Encoding.Unicode.GetBytes(str));
                    stream.Position = 0;
                    stream.Seek(0, System.IO.SeekOrigin.Begin);
                    result = formatter.Deserialize(stream) as T;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            return result;
        }


        #endregion




        #region WCF 序列化
        /// <summary>
        ///  WCF 序列化
        /// </summary>
        /// <param name="obj">WCF对象</param>
        /// <returns></returns>
        public static string DataContractSerialize(object obj)
        {
            string result = default(string);
            if (obj != null)
            {
                try
                {
                    MemoryStream stream = new MemoryStream();
                    System.Runtime.Serialization.DataContractSerializer se = new DataContractSerializer(obj.GetType());
                    se.WriteObject(stream, obj);
                    stream.Position = 0;
                    StreamReader sr = new StreamReader(stream);


                    result = sr.ReadToEnd();


                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            return result;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="str"></param>
        /// <returns></returns>
        public static T DataContractDeSerialize<T>(string str) where T : class
        {
            T result = default(T);
            if (str.Length > 0)
            {
                try
                {
                    MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(str));
                    stream.Position = 0;
                    stream.Seek(0, System.IO.SeekOrigin.Begin);


                    DataContractSerializer ser = new DataContractSerializer(typeof(T));
                    result = (T)ser.ReadObject(stream);
                    stream.Close();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            return result;
        }




        /// <summary>
        /// WCF
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string NetDataContractSerialize(object obj)
        {
            string result = default(string);
            if (obj != null)
            {
                try
                {
                    MemoryStream stream = new MemoryStream();
                    System.Runtime.Serialization.NetDataContractSerializer se = new NetDataContractSerializer();
                    se.WriteObject(stream, obj);
                    stream.Position = 0;
                    StreamReader sr = new StreamReader(stream);


                    result = sr.ReadToEnd();


                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            return result;
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="str"></param>
        /// <returns></returns>
        public static T NetDataContractDeSerialize<T>(string str) where T : class
        {
            T result = default(T);
            if (str.Length > 0)
            {
                try
                {
                    MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(str));
                    stream.Position = 0;
                    stream.Seek(0, System.IO.SeekOrigin.Begin);


                    NetDataContractSerializer ser = new NetDataContractSerializer();
                    result = (T)ser.ReadObject(stream);
                    stream.Close();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            return result;
        }
        #endregion


        #region XML序列化-对象以XML形式进行序列化并传输，不能完全保留对象数据与状态。
        /// <summary>
        /// XML序列化
        /// </summary>
        /// <param name="obj">对象</param>
        /// <returns></returns>
        public static string XmlSerialize(object obj)
        {
            StreamWriter sw = null;
            string serializeString = null;


            try
            {
                // 
                XmlSerializer xmlSerializer = new XmlSerializer(obj.GetType());
                MemoryStream memStream = new MemoryStream();
                sw = new StreamWriter(memStream);
                xmlSerializer.Serialize(sw, obj);
                memStream.Position = 0;
                serializeString = Encoding.UTF8.GetString(memStream.GetBuffer());
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (sw != null)
                {
                    sw.Close();
                }
            }


            return serializeString;
        }




        /// <summary>
        ///
        /// </summary>
        /// <param name="type"></param>
        /// <param name="serializedString"></param>
        /// <returns></returns>
        public static T XmlDeserialize<T>(string serializedString) where T : class
        {


            //
            if (serializedString.Trim().Equals(string.Empty))
            {
                throw new Exception("对象为空");
            }


            try
            {
                XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
                StringReader stringReader = new StringReader(serializedString);
                T obj = xmlSerializer.Deserialize(stringReader) as T;


                return obj;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion
    }