基于ObjectCache的应用

/// <summary>
    /// 缓存管理器接口类
    /// </summary>
    public interface ICacheManager
    {
        /// <summary>
        /// 以对象的形式获取缓存中的指定缓存项。
        /// </summary>
        /// <typeparam name="T">Type</typeparam>
        /// <param name="key"> 要获取的缓存项的唯一标识符。</param>
        /// <returns> 由 key 标识的缓存项.</returns>
        T Get<T>(string key);

        /// <summary>
        /// 向缓存中插入缓存项，同时指定基于时间的过期详细信息。
        /// </summary>
        /// <param name="key">该缓存项的唯一标识符。</param>
        /// <param name="data">要插入的对象。</param>
        /// <param name="cacheTime">缓存项的固定的过期日期和时间。</param>
        void Set(string key, object data, int cacheTime);

        /// <summary>
        ///   检查缓存中是否已存在该缓存项。
        /// </summary>
        /// <param name="key">该缓存项的唯一标识符。</param>
        /// <returns> 如果缓存中包含具有与 key 相同的键值的缓存项，则为 true；否则为 false。</returns>
        bool IsSet(string key);

        /// <summary>
        /// 从缓存中移除缓存项。
        /// </summary>
        /// <param name="key">/该缓存项的唯一标识符。</param>
        void Remove(string key);

        /// <summary>
        /// 通过正则表达式清除缓存
        /// </summary>
        /// <param name="pattern">pattern</param>
        void RemoveByPattern(string pattern);

        /// <summary>
        /// 清除缓存
        /// </summary>
        void Clear();
    }

/// <summary>
    /// 全局数据缓存MemoryCacheManager类，使用.net  缓存框架实现数据缓存
    /// </summary>
    public partial class MemoryCacheManager : ICacheManager
    {
        /// <summary>
        ///   表示一个对象缓存并提供用于访问该对象缓存的基方法和属性。
        /// </summary>
        protected ObjectCache Cache
        {
            get
            {
                return MemoryCache.Default;
            }
        }
       
        /// <summary>
        /// 在派生类中重写时，以对象的形式获取缓存中的指定缓存项。
        /// </summary>
        /// <typeparam name="T">Type</typeparam>
        /// <param name="key"> 要获取的缓存项的唯一标识符。</param>
        /// <returns> 由 key 标识的缓存项.</returns>
        public T Get<T>(string key)
        {
            return (T)Cache[key];
        }

        /// <summary>
        /// 在派生类中重写时，向缓存中插入缓存项，同时指定基于时间的过期详细信息。
        /// </summary>
        /// <param name="key">该缓存项的唯一标识符。</param>
        /// <param name="data">要插入的对象。</param>
        /// <param name="cacheTime">缓存项的固定的过期日期和时间。</param>
        public void Set(string key, object data, int cacheTime)
        {
            if (data == null)
                return;

            //  定义一个包含该缓存项的逐出详细信息的对象。此对象提供比简单绝对过期更多的逐出选项。
            var policy = new CacheItemPolicy();
            policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(cacheTime);
            Cache.Add(new CacheItem(key, data), policy);
        }

        /// <summary>
        ///   在派生类中重写时，检查缓存中是否已存在该缓存项。
        /// </summary>
        /// <param name="key">该缓存项的唯一标识符。</param>
        /// <returns> 如果缓存中包含具有与 key 相同的键值的缓存项，则为 true；否则为 false。</returns>
        public bool IsSet(string key)
        {
            return (Cache.Contains(key));
        }

        /// <summary>
        ///  在派生类中重写时，从缓存中移除缓存项。
        /// </summary>
        /// <param name="key">/该缓存项的唯一标识符。</param>
        public void Remove(string key)
        {
            Cache.Remove(key);
        }

        /// <summary>
        /// 通过正则匹配从缓存中移除缓存项。
        /// </summary>
        /// <param name="pattern">正则表达式</param>
        public void RemoveByPattern(string pattern)
        {
            var regex = new Regex(pattern, RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
            var keysToRemove = new List<String>();

            foreach (var item in Cache)
                if (regex.IsMatch(item.Key))
                    keysToRemove.Add(item.Key);

            foreach (string key in keysToRemove)
            {
                Remove(key);
            }
        }

        /// <summary>
        ///清除缓存
        /// </summary>
        public void Clear()
        {
            foreach (var item in Cache)
                Remove(item.Key);
        }
    }

/// <summary>
    ///缓存扩展类
    /// </summary>
    public static class CacheExtensions
    {
        /// <summary>
        /// 向缓存中插入缓存项或获取缓存中的指定缓存项
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="cacheManager">使用的缓存管理器</param>
        /// <param name="key">该缓存项的唯一标识符</param>
        /// <param name="acquire">委托类型</param>
        /// <returns></returns>
        public static T Get<T>(this ICacheManager cacheManager, string key, Func<T> acquire)
        {
            return Get(cacheManager, key, 60, acquire);
        }
        /// <summary>
        /// 向缓存中插入缓存项或获取缓存中的指定缓存项
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="cacheManager">使用的缓存管理器</param>
        /// <param name="key">该缓存项的唯一标识符</param>
        /// <param name="cacheTime">缓存项的固定的过期日期和时间</param>
        /// <param name="acquire">委托类型</param>
        /// <returns></returns>
        public static T Get<T>(this ICacheManager cacheManager, string key, int cacheTime, Func<T> acquire)
        {
            if (cacheManager.IsSet(key))
            {
                // 以对象的形式获取缓存中的指定缓存项。
                return cacheManager.Get<T>(key);
            }
            else
            {
                var result = acquire();
                     //向缓存中插入缓存项，同时指定基于时间的过期详细信息。
                    cacheManager.Set(key, result, cacheTime);
                return result;
            }
        }
    }