對象序列化工具

對象類的序列化輕型的XML和複雜型的byte[]方式

    /// <summary>
    /// 對象序列化工具
    /// </summary>
    public class ObjectSerializationHelper
    {
        /// <summary>
        /// 序列化集合
        /// </summary>
        private static Dictionary<int, XmlSerializer> xmlSerializer_dict = new Dictionary<int, XmlSerializer>();

        #region --- Functions Begin ---

        /// <summary>
        /// 獲取對象類型的序列化Xml格式
        /// </summary>
        /// <typeparam name="T">對象類型</typeparam>
        /// <returns>Xml格式</returns>
        private static XmlSerializer GetXmlSerializer<T>() where T : new()
        {
            int tHash = typeof(T).GetHashCode();

            if (!xmlSerializer_dict.ContainsKey(tHash))
            {
                xmlSerializer_dict.Add(tHash, new XmlSerializer(typeof(T)));
            }
            return xmlSerializer_dict[tHash];
        }

        /// <summary>
        /// 把對象序列化爲字符串
        /// </summary>
        /// <typeparam name="T">對象類型</typeparam>
        /// <param name="t">對象</param>
        /// <returns>序列化後的字符串，失敗則會拋出異常信息</returns>
        public static string SerializeToXmlString<T>(T t) where T : new()
        {
            string str = string.Empty;

            XmlSerializer xml = GetXmlSerializer<T>();
            MemoryStream ms = new MemoryStream();
            XmlTextWriter xtw = null;
            StreamReader sr = null;
            try
            {
                xtw = new System.Xml.XmlTextWriter(ms, Encoding.UTF8);
                xtw.Formatting = System.Xml.Formatting.Indented;
                xml.Serialize(xtw, t);
                ms.Seek(0, SeekOrigin.Begin);
                sr = new StreamReader(ms);
                str = sr.ReadToEnd();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (xtw != null)
                    xtw.Close();
                if (sr != null)
                    sr.Close();
                ms.Close();
            }

            return str;
        }

        /// <summary>
        /// 從字符竄反序列化爲對象
        /// </summary>
        /// <typeparam name="T">對象類</typeparam>
        /// <param name="s">需要反序列化的字符串</param>
        /// <returns>該對象實例,失敗則會拋出異常信息</returns>
        public static T DeSerializeForXmlString<T>(string s) where T : new()
        {
            byte[] bArray = System.Text.Encoding.UTF8.GetBytes(s);

            try
            {
                XmlSerializer xml = GetXmlSerializer<T>();
                return (T)xml.Deserialize(new MemoryStream(bArray));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 對象序列化爲Byte數組
        /// </summary>
        /// <typeparam name="T">對象類</typeparam>
        /// <param name="t">來源對象</param>
        /// <returns>返回結果</returns>
        public static byte[] SerializeToBytes<T>(T t) where T : new()
        {
            using (MemoryStream stream = new MemoryStream())
            {
                try
                {
                    byte[] buf = null;
                    IFormatter formatter = new BinaryFormatter();
                    formatter.Serialize(stream, t);
                    buf = stream.ToArray();
                    stream.Close();
                    return buf;
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }

        /// <summary>
        /// 序列化爲Byte數組對象還原爲對象實體
        /// </summary>
        /// <typeparam name="T">對象類型</typeparam>
        /// <param name="buf">對象序列化後數據</param>
        /// <returns></returns>
        public static T DeSerializeForBytes<T>(byte[] buf) where T : new()
        {
            try
            {
                using (MemoryStream stream = new MemoryStream(buf))
                {
                    IFormatter formatter = new BinaryFormatter();
                    return (T)formatter.Deserialize(stream);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 簡單克隆利用Xml模式進行序列化克隆
        /// </summary>
        /// <typeparam name="T">對象類型</typeparam>
        /// <param name="obj">對象實體</param>
        /// <returns>對象副本</returns>
        public static T SimpleClone<T>(T obj) where T : new()
        {
            try
            {
                string xmlString = SerializeToXmlString(obj);

                return DeSerializeForXmlString<T>(xmlString);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 高級克隆利用內存流模式進行序列化克隆
        /// </summary>
        /// <typeparam name="T">對象類型</typeparam>
        /// <param name="obj">對象實體</param>
        /// <returns>對象副本</returns>
        public static T AdvancedClone<T>(T obj) where T : new()
        {
            try
            {
                byte[] buf = SerializeToBytes(obj);
                return DeSerializeForBytes<T>(buf);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /*
        /// <summary>
        /// 克隆對象
        /// </summary>
        public static class ObjectCloner
        {
            /// <summary>
            /// 克隆對象
            /// </summary>
            /// <param name="obj">需要克隆的對象</param>
            /// <returns>返回當前對象的克隆對象</returns>
            public static T Clone<T>(T obj) where T : new()
            {
                try
                {
                    using (MemoryStream stream = new MemoryStream())
                    {
                        BinaryFormatter formatter = new BinaryFormatter();
                        formatter.Serialize(stream, obj);
                        stream.Position = 0L;
                        return (T)formatter.Deserialize(stream);
                    }
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }
        */

        #endregion --- Functions End ---
    }