本人开发的缓存类

namespace ITA.Base.EntLib.Caching
{


    /// <summary>
    /// 企业库缓存
    /// </summary>
    public class Cache : IDisposable, ICache
    {
        private Hashtable inMemoryCache;
        DataDelegate _Motheds;
        /// <summary>
        /// 必填项目 方法名字，表示如果数据不存在，使用该方法填充数据(Motheds(DataForBase))
        /// </summary>
        public DataDelegate Motheds
        {
            get { return _Motheds; }
            set { _Motheds = value; }
        }

        /// <summary>
        /// 获取缓存
        /// </summary>
        /// <param name="initialItems"></param>
        public Cache(Hashtable initialItems )
        {
            inMemoryCache = Hashtable.Synchronized(initialItems);
            //IManager = Manager;
        }
        /// <summary>
        /// 获取有多少个count
        /// </summary>
        public int Count
        {
            get { return inMemoryCache.Count; }
        }

        public Hashtable CurrentCacheState
        {
            get { return (Hashtable)inMemoryCache.Clone(); }
        }

        public void Remove(object key)
        {
            bool lockWasSuccessful;
            CacheItem cacheItemBeforeLock = null;
            do{
                lock (inMemoryCache.SyncRoot)
                {
                    cacheItemBeforeLock = (CacheItem)inMemoryCache[key];
                    lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
                }
            } while (lockWasSuccessful == false);

            //IManager.CacheRemove(key);
            inMemoryCache.Remove(key);
           
            Monitor.Exit(cacheItemBeforeLock);

        }

        public void Add(object key, object value, CacheItemPriority scavengingPriority, DateTime dt)
        {
            bool lockWasSuccessful;
            CacheItem cacheItemBeforeLock = null;
            do
            {
                lock (inMemoryCache.SyncRoot)
                {
                    cacheItemBeforeLock = new CacheItem( false, null, CacheItemPriority.Normal, dt);
                    inMemoryCache.Add(key, cacheItemBeforeLock);
                    lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
                }
            } while (lockWasSuccessful == false);
            // IManager.CacheAdd(key, value, dt, CacheItemPriority.Normal);
            cacheItemBeforeLock.IsCacheOk = true;
            cacheItemBeforeLock.Data = value;
            inMemoryCache[key] = cacheItemBeforeLock;

            Monitor.Exit(cacheItemBeforeLock);

        }
        /// <summary>
        /// 根据Key获取相关的数据,如果没有数据，则通过values去获取数据
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public CacheItem GetItem(object key, object values)
        {
            CacheItem _cacheItem = null;

            if (inMemoryCache.ContainsKey(key))
            {
                _cacheItem = (CacheItem)inMemoryCache[key];
                if (_cacheItem.IsCacheOk)
                {
                    //从缓存中获取数据
                    //_cacheItem.Data = IManager.CacheItemDate(key);
                    if (_cacheItem.Data == null)
                    {
                        Remove(key);
                        _cacheItem = null;

                    }
                }
                else
                {
                    //三秒钟内获取数据
                    for (int i = 0; i < 150; i++)
                    {
                        Thread.Sleep(20);
                        _cacheItem = (CacheItem)inMemoryCache[key];
                        if (_cacheItem.Data != null)
                        {
                            break;
                        }
                        else
                        {
                            continue;
                        }
                    }
                }
            }
            else
            {
                //如果没有数据
                //object values = methodes(forbase);
                ClearExdateCache();
                Add(key, values, CacheItemPriority.Low, DateTime.Now.AddSeconds(30));
                _cacheItem = (CacheItem)inMemoryCache[key];
            }
            return _cacheItem;
        }
        /// <summary>
        /// 清除已经过期的缓存
        /// </summary>
        public void ClearExdateCache()
        {
            lock (inMemoryCache.SyncRoot)
            {
                //Hashtable ht = inMemoryCache.Clone()
                foreach (object key in CurrentCacheState.Keys)
                {
                    CacheItem item = (CacheItem)inMemoryCache[key];
                    if (item.LastAccessedTime <= DateTime.Now)
                    {
                        inMemoryCache.Remove(key);
                        //IManager.CacheRemove(key.ToString());
                    }
                }
            }
        }
        /// <summary>
        /// 删除最快过期的一个缓存
        /// </summary>
        public void RemoveCacheLastDateOut()
        {
            lock (inMemoryCache.SyncRoot)
            {
                CacheItem ditem=null;
                object key_ = null;
                foreach (object key in CurrentCacheState.Keys)
                {
                    CacheItem item = (CacheItem)inMemoryCache[key];
                    if (ditem == null)
                    {
                        ditem = item;
                        key_ = key;
                        continue;
                    }
                    else
                    {
                        if (ditem.LastAccessedTime > item.LastAccessedTime)
                        {
                            key_ = key;
                            ditem = item;
                        }
                    }
                }
                inMemoryCache.Remove(key_);
                //IManager.CacheRemove(ditem.Key);
            }
        }

        /// <summary>
        /// 删除缓存等级最低，最快过期的一个缓存
        /// </summary>

        public void RemoveCacheByCacheItemPriority()
        {
            lock (inMemoryCache.SyncRoot)
            {
                CacheItem ditem = null;
                object key_ = null;
                foreach (object key in CurrentCacheState.Keys)
                {
                    CacheItem item = (CacheItem)inMemoryCache[key];
                    if (ditem == null)
                    {
                        ditem = item;
                        key_ = key;
                        continue;
                    }
                    else
                    {
                        if (ditem.ScavengingPriority > item.ScavengingPriority)
                        {
                            ditem = item;
                            key_ = key;
                        }
                        else
                        {
                            if (ditem.ScavengingPriority == item.ScavengingPriority && ditem.LastAccessedTime > item.LastAccessedTime)
                            {
                                ditem = item;
                                key_ = key;
                            }
                        }
                    }
                }
                inMemoryCache.Remove(key_);
            }
        }


        ~Cache()
        {
            Dispose(false);
        }
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                inMemoryCache = null;
                //backingStore.Dispose();
                //backingStore = null;
            }
        }


        public object DataDoing( DataDelegate Mothed,object forbase)
        {
             return Mothed(forbase);
        }



    }
}

namespace ITA.Base.EntLib.Caching
{
    /// <summary>
    /// 缓存的类型
    /// </summary>
    public enum CacheItemPriority
    {
        /// <summary>
        /// Should never be seen in nature.
        /// </summary>
        None = 0,
        /// <summary>
        /// Low priority for scavenging.
        /// </summary>
        Low = 1,
        /// <summary>
        /// Normal priority for scavenging.
        /// </summary>
        Normal,
        /// <summary>
        /// High priority for scavenging.
        /// </summary>
        High,
        /// <summary>
        /// Non-removable priority for scavenging.
        /// </summary>
        NotRemovable
    }
}

namespace ITA.Base.EntLib.Caching
{
    /// <summary>
    /// 数据缓存的接口
    /// </summary>
    public interface ICache
    {
        Hashtable CurrentCacheState { get; }
        /// <summary>
        /// 获取有多少条数据
        /// </summary>
        int Count { get; }
        /// <summary>
        /// 删除指定值的缓存
        /// </summary>
        /// <param name="key"></param>
        void Remove(object key);
        /// <summary>
        /// 添加一条缓存
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        /// <param name="scavengingPriority">缓存等级</param>
        /// <param name="dt">过期时间</param>
        void Add(object key, object value, CacheItemPriority scavengingPriority, DateTime dt);
        /// <summary>
        /// 获取指定键的缓存,如果值不存在，则用values填充(默认缓存30秒)
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        CacheItem GetItem(object key, object values);
        /// <summary>
        /// 删除已经过期的缓存
        /// </summary>
        void ClearExdateCache();
        /// <summary>
        /// 删除等级最低，最快过期的一条缓存
        /// </summary>
        void RemoveCacheByCacheItemPriority();
        object DataDoing(DataDelegate Mothed, object forbase);
    }
}

namespace ITA.Base.EntLib.DataHelper
{
    public class DataForBase
    {
       // IList<LinkDataType> _Para;
        CommandType _CommandType;
        /// <summary>
        /// 指定如何解析字符串
        /// </summary>
        public CommandType CommandType
        {
            get { return _CommandType; }
            set { _CommandType = value; }
        }
        string _SQLStoredName;
        /// <summary>
        /// 存储过程、表或者语句的名称
        /// </summary>
        public string SQLStoredName
        {
            get { return _SQLStoredName; }
            set { _SQLStoredName = value; }
        }

        private IList<LinkDataType> _LinkDataTypeList;

        /// <summary>
        /// 对应存贮过程的数据类型集合
        /// </summary>
        public IList<LinkDataType> LinkDataTypeList
        {
            get { return _LinkDataTypeList; }
            set { _LinkDataTypeList = value; }
        }
    }
}

namespace ITA.Base.EntLib.DataHelper
{
    /// <summary>
    /// 用于数据缓存的类，代表key
    /// </summary>
    public class DataHelperPara : HelperPara,IHelperPara
    {
        DataForBase _Para;
        /// <summary>
        /// 数据对象
        /// </summary>
        public object Para
        {
            get { return _Para; }
            set { _Para = (DataForBase)value; }
        }
    }
}

namespace ITA.Base.EntLib.FileHelper
{
    /// <summary>
    /// 用于数据缓存的类，代表key
    /// </summary>
    public class XMLHelperPara :HelperPara, IHelperPara
    {
        XMLForBase _Para;
        /// <summary>
        /// 数据路径(FileForBase类型)
        /// </summary>
        public object Para
        {
            get { return _Para; }
            set { _Para = (XMLForBase)value; }
        }



    }
}

namespace ITA.Base.EntLib
{
    public class HelperPara
    {
        string _nameSpace;
        /// <summary>
        /// 空间命名
        /// </summary>
        public string NameSpace
        {
            get { return _nameSpace; }
            set { _nameSpace = value; }
        }
        string _className;
        /// <summary>
        /// 类名
        /// </summary>
        public string ClassName
        {
            get { return _className; }
            set { _className = value; }
        }
        string _Mothed;
        /// <summary>
        /// 方法名
        /// </summary>
        public string Mothed
        {
            get { return _Mothed; }
            set { _Mothed = value; }
        }

    }
}

namespace ITA.Base.EntLib
{
    public interface IHelperPara
    {
        /// <summary>
        /// 空间命名
        /// </summary>
        string NameSpace
        {
            get;
            set;
        }
        /// <summary>
        /// 当前类名
        /// </summary>
        string ClassName
        {
            get;
            set;
        }
        /// <summary>
        /// 方法名
        /// </summary>
        string Mothed
        {
            get;
            set;
        }
        /// <summary>
        /// FileForBase/DataForBase/XMLForBase 类
        /// </summary>
        object Para
        {
            get;
            set;
        }
    }
}