通用序列化基类 只须实现该类抽象成员即可进行序列化与反序列化

转载请注明出处 http://www.cnblogs.com/68681395

  1//是否写日志
  2#define txtLogAll
  3
  4using System;
  5using System.Web;
  6using System.Xml.Serialization;
  7using System.IO;
  8using System.Runtime.Serialization;
  9using System.Runtime.Serialization.Formatters.Soap;
 10using System.Runtime.Serialization.Formatters.Binary;
 11using System.Web.Caching;
 12using System.Threading;
 13using tjb.Utility.Caching;
 14using System.Xml;
 15using System.Text;
 16
 17
 18namespace tjb.Utility.Config
 19{
 20
 21    文件序列化的类型#region  文件序列化的类型
 22    /**//// <summary>
 23    /// 序列化文件的方式
 24    /// Binary，Xml，SoapXml
 25    /// </summary>
 26    public enum Formatter
 27    {
 28        /**//// <summary>
 29        /// 字节
 30        /// </summary>
 31        Binary,
 32        /**//// <summary>
 33        /// xml
 34        /// </summary>
 35        Xml,
 36        /**//// <summary>
 37        /// soap协议的xml
 38        /// </summary>
 39        SoapXml
 40    }
 41    #endregion
 42
 43    /**//// <summary>
 44    /// 序列化基类  by Tjb 2007/06 
 45    /// T 类型不能创建多态的多个实例
 46    /// 优化和修正，增加配置文件备份 2008/9/18
 47    /// 修改：获取实例时加锁
 48    /// 修改：
 49    /// SaveAs(T Tobj, string FileFullName, bool BackupOnError) 方法增加线程锁定。防止多线程冲突 2008/10/24
 50    /// </summary>
 51    /// <typeparam name="T">T 必须有无参数的构造函数</typeparam>
 52    [Serializable]
 53    public abstract class IConfig<T> where T : IConfig<T>, new()
 54    {
 55
 56        Exceptions#region Exceptions
 57        private Exception __ConfigException;
 58        /**//// <summary>
 59        /// 读取或保存时发生的错误
 60        /// </summary>
 61        [XmlIgnore, SoapIgnore]
 62        public Exception Exception
 63        {
 64            get
 65            {
 66                return __ConfigException;
 67            }
 68            private set
 69            {
 70                if (value != null)
 71                {
 72                    HasError = true;
 73                    __ConfigException = value;
 74#if txtLogAll
 75                    Log.WriteLog(value);
 76#endif
 77                }
 78            }
 79        }
 80        private bool __HasError = false;
 81        /**//// <summary>
 82        /// 获取一个值 指示读取或者保存时是否发生错误
 83        /// 如果当前错误被获取后，此标志将被置为false
 84        /// </summary>
 85        [XmlIgnore, SoapIgnore]
 86        public bool HasError
 87        {
 88            get { return __HasError; }
 89            private set { __HasError = value; }
 90        }
 91        #endregion
 92
 93        序列化类型  可重写#region 序列化类型  可重写
 94
 95        private Formatter _CurrentFormatter = Formatter.Xml;
 96        /**//// <summary>
 97        /// 序列化的方式
 98        /// </summary>      
 99        [XmlIgnore]
        protected virtual Formatter CurrentFormatter
        {
            get
            {
                return _CurrentFormatter;
            }
            set
            {
                _CurrentFormatter = value;
            }
        }

        #endregion

        获取单个实例#region 获取单个实例

        /**//// <summary>
        /// 获取Cache中缓存T的key
        /// </summary>
        public static string CacheKEY
        {
            get
            {
                // return typeof(T).GUID.ToString("N");
                return typeof(T).FullName;
            }
        }
        /**//// <summary>
        /// 从缓存（缓存KEY为T的命空间加类名）获取当前类的实例，如果缓存不存在则读取文件(ConfigFileFullName)， 并缓存。 
        /// </summary>
        public static T Instance
        {
            get
            {
                T c = CacheUtility.Get<T>(CacheKEY);
                if (c == null)
                {
                    //这中方式无异于不加锁
                    //object Monitor = new object();
                    //lock (Monitor)
                    lock (typeof(T))
                    {
                        c = CacheUtility.Get<T>(CacheKEY);
                        if (c == null)
                        {
                            c = new T().Read();
#if DEBUG
                            CacheUtility.SetSlidingExpiration(CacheKEY, c, c.ConfigFileFullName, 7, CacheItemPriority.NotRemovable, new CacheItemRemovedCallback(CallR));
#else
                            CacheUtility.SetSlidingExpiration(CacheKEY, c, c.ConfigFileFullName, 7, CacheItemPriority.NotRemovable, null);
#endif
                        }
                    }
                }
                return c;
            }
        }

        #endregion

        Caching..#region Caching..

        /**//// <summary>
        /// 从ConfigFileName指定文件以CurrentSerializeType读取实例，如果存在缓存则移除并重新进行缓存
        /// 如果不存在则以InitConfig初始化类,创建并保存文件
        /// </summary>
        /// <returns></returns>
        protected T ResetCacheAndRead()
        {
            ResetCache();
            return Read();
        }
        /**//// <summary>
        /// 移除CacheKEY 缓存
        /// </summary>
        public void ResetCache()
        {
            HttpRuntime.Cache.Remove(CacheKEY);
        }
        #endregion

        获取#region 获取

        /**//// <summary>
        /// 读取缓存中的实例如果不存在则
        /// 从ConfigFileName指定文件以CurrentSerializeType读取实例
        /// 如果不存在则以InitConfig初始化类,创建并保存文件
        /// </summary>
        /// <returns></returns>
        virtual protected T Read()
        {
            return Read(ConfigFileFullName, true, CurrentFormatter);
        }

        /**//// <summary>
        ///  从ConfigFileName指定文件以CurrentSerializeType读取实例
        ///  如果不存在则以InitConfig初始化类,创建并保存文件
        /// </summary>
        /// <param name="configFileFullName">缓存文件绝对路径</param>
        /// <param name="serializeType"></param>
        /// <param name="BackupOnError">读取错误时是否备份</param>
        /// <returns></returns>
        protected T Read(string configFileFullName, bool BackupOnError, Formatter serializeType)
        {
            T t = CacheUtility.Get<T>(CacheKEY);
            if (t != null)
                return t;
            FileInfo fi = new FileInfo(configFileFullName);
            if (fi.Exists)
            {

                FileStream fs = null;
                try
                {
                    open the stream#region  open the stream
                    // open the stream
                    fs = new FileStream(fi.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                    IFormatter formatter = null;
                    switch (serializeType)
                    {
                        case Formatter.Binary:
                            formatter = new BinaryFormatter();
                            t = formatter.Deserialize(fs) as T;
                            break;
                        case Formatter.SoapXml:
                            formatter = new SoapFormatter();
                            t = formatter.Deserialize(fs) as T;
                            break;
                        case Formatter.Xml:
                            XmlSerializer serializer = new XmlSerializer(typeof(T));
                            t = serializer.Deserialize(fs) as T;
                            break;
                        default:
                            break;
                    }
                    #endregion

                    if (fs != null)
                        fs.Close();
                }
                catch (Exception ex)
                {
                    if (fs != null)
                        fs.Close();
                    t = CustomizingInit();

                    读取失败 进行备份 防止以后使用默认配置覆盖当前数据#region 读取失败 进行备份 防止以后使用默认配置覆盖当前数据
                    if (BackupOnError)
                        if (fi.Exists)
                        {
                            string BackupFilePath = fi.FullName + ".Read." + DateTime.Now.ToString("yyMMddHHssfff") + ".bak";
                            try
                            {
                                fi.CopyTo(BackupFilePath, true);
                                t.Save(true);
                            }
                            catch (Exception ioex)
                            {
                                t.Exception = new Exception("读取配置文件出错后，对配置文件进行备份发生错误！", ioex);
                            }
                        }
                    #endregion

                    t.Exception = new Exception("读取配置文件时发生错误！将返回CustomizingInit()方法的实例，默认为 new T()！", ex);
                }
                finally
                {

                }
            }
            else
            {
                t = CustomizingInit();

                //不存在的同一文件不能读多次
                //防止在CustomizingInit()方法中调用Read(string configFileName, SerializeType serializeType) 造成死循环
                string ProtectedKEY = Thread.CurrentThread.ManagedThreadId + fi.FullName + "init";
                if (CacheUtility.GetAnyType<bool>(ProtectedKEY) == false)
                {
                    CacheUtility.SetAbsoluteExpiration(ProtectedKEY, true, null, 0.02);
                }
                else
                {
                    CacheUtility.Remove(ProtectedKEY);
                    throw new Exception("'" + fi.FullName + "' 文件不存在！读取过于频繁。导致此保护异常发生。");
                }
                t.Exception = new Exception("配置文件：'" + fi.FullName + "' 不存在！默认返回CustomizingInit()方法返回的实例。");
            }
            if (t == null)
                t.Exception = new Exception("发生错误，请检查初始化配置方法 CustomizingInit() 未返回的配置实例不能为空，或者系统中存在缓存 key ：" + CacheKEY);
            return t;
        }

#if DEBUG
        private static void CallR(string key, object obj, CacheItemRemovedReason re)
        {
#if txtLogAll
            Log.WriteLog(key + "::::" + re.ToString());
#endif
        }
#endif

        #endregion

        保存#region 保存
        /**//// <summary>
        /// 将当前实例进行保存
        /// </summary>
        /// <param name="BackupOnError">发生错误时是否备份</param>
        /// <returns></returns>
        public bool Save(bool BackupOnError)
        {
            if (Current == null)
            {
                Exception = new Exception(typeof(T).FullName + " 未正确实现 Current；");
                return false;
            }
            return Save(Current, BackupOnError);
        }
        /**//// <summary>
        /// 将当前实例进行保存
        /// 发生错误时将备份配置文件
        /// </summary>
        /// <returns></returns>
        public virtual bool Save()
        {
            return Save(true);
        }

        /**//// <summary>
        /// 将当前实例保存到T.ConfigFileName指定的配置文件
        /// </summary>
        /// <param name="Tobj"></param>
        /// <param name="BackupOnError"></param>
        /// <returns></returns>      
        public bool Save(T Tobj, bool BackupOnError)
        {
            return SaveAs(Tobj, ConfigFileFullName, BackupOnError);
        }

        /**//// <summary>
        /// 将一个实例对象保存到FileFullName指定的配置文件
        /// </summary>
        /// <param name="FileFullName"></param>
        /// <param name="Tobj"></param>
        /// <param name="BackupOnError"></param>
        /// <returns></returns>      
        protected bool SaveAs(T Tobj, string FileFullName, bool BackupOnError)
        {
            lock (typeof(T))
            {
                if (Tobj == default(T))
                {
                    Exception = new Exception(typeof(T).FullName + " 未正确实现 Current；");
                    return false;
                }
                FileStream fs = null;
                FileInfo fi = new FileInfo(FileFullName);
                string BackupFilePath = null;

                if (BackupOnError)
                {
                    backup#region backup

                    BackupFilePath = fi.FullName + ".Save." + DateTime.Now.ToString("yyMMddHHssfff") + ".bak";
                    try
                    {
                        //如果存在先备份
                        if (fi.Exists)
                        {
                            fi.CopyTo(BackupFilePath, true);
                        }
                        else if (!fi.Directory.Exists)
                        {
                            //目录不存在创建目录
                            fi.Directory.Create();
                        }
                    }
                    catch (Exception ex)
                    {
                        Tobj.Exception = new Exception("备份配置文件时发生错误！", ex);
                        return false;
                    }
                    #endregion
                }

                try
                {
                    if (fi.Exists)
                        fi.Delete();
                    serialize it#region  serialize it
                    fs = new FileStream(fi.FullName, FileMode.Create, FileAccess.Write, FileShare.Read);
                    IFormatter formatter = null;
                    switch (CurrentFormatter)
                    {
                        case Formatter.Binary:
                            formatter = new BinaryFormatter();
                            formatter.Serialize(fs, Tobj);
                            break;
                        case Formatter.SoapXml:
                            formatter = new SoapFormatter();
                            formatter.Serialize(fs, Tobj);
                            break;
                        case Formatter.Xml:
                            XmlSerializer serializer = new XmlSerializer(typeof(T));

                            serializer.Serialize(fs, Tobj);
                            break;
                        default:
                            break;
                    }
                    #endregion

                    //成功则删除当前备份

                    成功则删除当前备份#region 成功则删除当前备份
                    if (BackupOnError)
                        try
                        {
                            File.Delete(BackupFilePath);
                        }
                        catch (Exception ex)
                        {
                            Tobj.Exception = new Exception("删除备份文件时发生错误！", ex);
                        }
                    #endregion

                    return true;
                }
                catch (Exception ex)
                {
#if txtLog
                Log.WriteLog(ex);
#endif
                    Tobj.Exception = new Exception("保存配置文件时发生错误！", ex);

                    return false;
                }
                finally
                {
                    if (fs != null)
                        fs.Close();
                }
            }
        }
        #endregion

        删除配置文件#region 删除配置文件
        /**//// <summary>
        /// 删除配置文件
        /// </summary>
        /// <returns></returns>
        public bool Delete()
        {
            return Delete(ConfigFileFullName);
        }
        /**//// <summary>
        /// 删除指定的配置文件 .文件不存在不引发异常。并返回true
        /// </summary>
        /// <param name="FileFullName"></param>
        /// <returns></returns>
        public bool Delete(string FileFullName)
        {
            try
            {
                if (File.Exists(FileFullName))
                    File.Delete(FileFullName);
                return true;
            }
            catch (Exception ex)
            {
                Current.Exception = ex;
                return false;
            }
        }
        #endregion

        抽象成员#region  抽象成员
        /**//// <summary>
        /// 返回派生类的当前实例
        /// protected override T Current
        /// {
        ///     get
        ///     {
        ///         return this;
        ///     }
        /// } 
        /// </summary>
        protected abstract T Current
        {
            get;
        }
        /**//// <summary>
        /// 自定义初始化配置类
        /// 获取 T 的配置实例时，如果配置文件不存在或者读取失败时返回此实例
        /// 重写中一般读取备份的配置文件，必须保证备份配置文件存在，否则发生异常。
        /// 默认返回    new T();
        /// </summary>
        /// <returns></returns>
        protected virtual T CustomizingInit()
        {
            return Current;
        }
        /**//// <summary>
        /// 配置文件名
        /// <c>配置文件名</c>
        /// <example>
        /// 配置文件名
        /// </example>
        /// </summary>
        private string ___file = Path.Combine(System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "Config/" + typeof(T).Name + ".cfg");
        /**//// <summary>
        /// 配置文件全路径名
        /// 默认：winform 在应用程序目录；web应用程序默认bin目录。
        /// </summary>
        [XmlIgnore]
        public virtual string ConfigFileFullName
        {
            get
            {
                return ___file;
            }
            set
            {
                ___file = value;
            }
        }
        #endregion
    }
}