c# .Net 緩存 使用System.Runtime.Caching 做緩存 平滑過期，絕對過期

public class CacheHeloer
{

    /// <summary>
    /// 默認緩存
    /// </summary>
    private static CacheHeloer Default { get { return new CacheHeloer(); } }

    /// <summary>
    /// 緩存初始化
    /// </summary>
    private MemoryCache cache = MemoryCache.Default;

    /// <summary>
    /// 鎖
    /// </summary>
    private object locker = new object();

    /// <summary>
    /// 構造器
    /// </summary>
    private CacheHeloer()
    {
        //CacheItemPolicy policy = new CacheItemPolicy();  //創建緩存項策略
        ////過期時間設置,以下兩種只能設置一種
        //policy.AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(5)); //設定某個時間過后將逐出緩存
        //policy.SlidingExpiration = new TimeSpan(0, 0, 10);    //設定某個時間段內未被訪問將逐出緩存
        ////逐出通知,以下兩種只能設置一種
        //policy.UpdateCallback = arguments => { Console.WriteLine("即將逐出緩存" + arguments.Key); };
    }

    /// <summary>
    /// 從緩存中獲取對象
    /// </summary>
    /// <typeparam name="T">對象類型</typeparam>
    /// <param name="key">鍵</param>
    /// <returns>緩存對象</returns>
    public static object Get(string key)
    {
        return Default.GetFromCache(key);
    }

    /// <summary>
    /// 從緩存中獲取對象
    /// </summary>
    /// <typeparam name="T">對象類型</typeparam>
    /// <param name="key">鍵</param>
    /// <returns>緩存對象</returns>
    private object GetFromCache(string key)
    {
        lock (locker)
        {
            if (cache.Contains(key))
            {
                return cache[key];
            }
            return null;
        }
    }

    /// <summary>
    /// 設置緩存指定時間未訪問過期
    /// </summary>
    /// <typeparam name="T">對象</typeparam>
    /// <param name="key">鍵</param>
    /// <param name="value">數據對象</param>
    /// <param name="expire">過期時間</param>
    public static bool Set(string key, Object value, TimeSpan expiresIn)
    {
        var policy = new CacheItemPolicy()
        {
            SlidingExpiration = expiresIn
        };
        return Default.SetToCache(key, value, policy);
    }
    /// <summary>
    /// 設置緩存絕對時間過期
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <param name="expiresIn"></param>
    /// <returns></returns>
    public static bool Set(string key, Object value, DateTimeOffset expiresIn)
    {
        var policy = new CacheItemPolicy()
        {
            AbsoluteExpiration = expiresIn
        };
        return Default.SetToCache(key, value, policy);
    }

    /// <summary>
    /// 添加到緩存
    /// </summary>
    /// <typeparam name="T">緩存對象類型</typeparam>
    /// <param name="key">鍵</param>
    /// <param name="value">值</param>
    /// <returns>結果狀態</returns>
    public static bool Set(string key, object value)
    {
        CacheItemPolicy policy = new CacheItemPolicy()
        {
            Priority = CacheItemPriority.NotRemovable,
        };
        return Default.SetToCache(key, value, policy);
    }

    /// <summary>
    /// 數據對象裝箱緩存
    /// </summary>
    /// <typeparam name="T">對象</typeparam>
    /// <param name="key">鍵</param>
    /// <param name="value">數據對象</param>
    /// <param name="expire">過期時間</param>
    private bool SetToCache(string key, object value, CacheItemPolicy policy)
    {
        lock (locker)
        {
            cache.Set(key, value, policy);
            return true;
        }
    }

    /// <summary>
    /// 獲取鍵的集合
    /// </summary>
    /// <returns>鍵的集合</returns>
    public static ICollection<string> Keys()
    {
        return Default.GetCacheKeys();
    }

    /// <summary>
    /// 獲取鍵的集合
    /// </summary>
    /// <returns>鍵的集合</returns>
    private ICollection<string> GetCacheKeys()
    {
        lock (locker)
        {
            IEnumerable<KeyValuePair<string, object>> items = cache.AsEnumerable();
            return items.Select(m => m.Key).ToList();
        }
    }

    /// <summary>
    /// 判斷緩存中是否有此對象
    /// </summary>
    /// <param name="key">鍵</param>
    /// <returns>是否存在</returns>
    public static bool Contain(string key)
    {
        return Default.ContainKey(key);
    }

    /// <summary>
    /// 判斷緩存中是否有此對象
    /// </summary>
    /// <param name="key">鍵</param>
    /// <returns>是否存在</returns>
    private bool ContainKey(string key)
    {
        lock (locker)
        {
            return cache.Contains(key);
        }
    }

    /// <summary>
    /// 數據對象從緩存對象中移除
    /// </summary>
    /// <param name="key">鍵</param>
    public static bool Remove(string key)
    {
        return Default.RemoveFromCache(key);
    }

    /// <summary>
    /// 數據對象從緩存對象中移除
    /// </summary>
    /// <param name="key">鍵</param>
    private bool RemoveFromCache(string key)
    {
        lock (locker)
        {
            if (cache.Contains(key))
            {
                cache.Remove(key);
                return true;
            }
            return false;
        }
    }

    /// <summary>
    /// 清除實例
    /// </summary>
    public static void Clear()
    {
        Default.ClearCache();
    }

    /// <summary>
    /// 清除實例
    /// </summary>
    private void ClearCache()
    {
        lock (locker)
        {
            cache.ToList().ForEach(m => cache.Remove(m.Key));
        }
    }

    /// <summary>
    /// 獲取緩存對象集合
    /// </summary>
    /// <typeparam name="T">緩存對象類型</typeparam>
    /// <returns>緩存對象集合</returns>
    public static ICollection<T> Values<T>()
    {
        return Default.GetValues<T>();
    }

    /// <summary>
    /// 獲取緩存對象集合
    /// </summary>
    /// <typeparam name="T">緩存對象類型</typeparam>
    /// <returns>緩存對象集合</returns>
    private ICollection<T> GetValues<T>()
    {
        lock (locker)
        {
            IEnumerable<KeyValuePair<string, object>> items = cache.AsEnumerable();
            return items.Select(m => (T)m.Value).ToList();
        }
    }

    /// <summary>
    /// 獲取緩存尺寸
    /// </summary>
    /// <returns>緩存尺寸</returns>
    public static long Size()
    {
        return Default.GetCacheSize();
    }

    /// <summary>
    /// 獲取緩存尺寸
    /// </summary>
    /// <returns>緩存尺寸</returns>
    private long GetCacheSize()
    {
        lock (locker)
        {
            return cache.GetCount();
        }
    }
}

?