好用的Cache辅助工具类

话不多说，直接上代码

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Collections;
 using System.Web;
 using System.Web.Caching;

 namespace Tools
 {
     /// <summary>
     /// 缓存辅助类
     /// </summary>
     public static class CacheHelper
     {
         #region // 绝对缓存过期时间
         public static DateTime Absolute_Minute_1
         {
             get { return DateTime.Now.AddMinutes(); }
         }

         public static DateTime Absolute_Minute_10
         {
             get { return DateTime.Now.AddMinutes(); }
         }

         public static DateTime Absolute_Minute_30
         {
             get { return DateTime.Now.AddMinutes(); }
         }

         public static DateTime Absolute_Hour_1
         {
             get { return DateTime.Now.AddHours(); }
         }

         public static DateTime Absolute_Hour_2
         {
             get { return DateTime.Now.AddHours(); }
         }

         public static DateTime Absolute_Hour_5
         {
             get { return DateTime.Now.AddHours(); }
         }

         public static DateTime Absolute_Hour_12
         {
             get { return DateTime.Now.AddHours(); }
         }

         public static DateTime Absolute_Day_1
         {
             get { return DateTime.Now.AddDays(); }
         }

         public static DateTime Absolute_Day_7
         {
             get { return DateTime.Now.AddDays(); }
         }

         public static DateTime Absolute_Day_14
         {
             get { return DateTime.Now.AddDays(); }
         }

         public static DateTime Absolute_Day_15
         {
             get { return DateTime.Now.AddDays(); }
         }

         public static DateTime Absolute_Month_1
         {
             get { return DateTime.Now.AddMonths(); }
         }
         #endregion

         #region // 滑动缓存过期时间
         public static TimeSpan Sliding_Minute_1
         {
             get { return new TimeSpan(TimeSpan.TicksPerMinute); }
         }

         public static TimeSpan Sliding_Minute_10
         {
             get { return new TimeSpan(TimeSpan.TicksPerMinute * ); }
         }

         public static TimeSpan Sliding_Minute_30
         {
             get { return new TimeSpan(TimeSpan.TicksPerMinute * ); }
         }

         public static TimeSpan Sliding_Hour_1
         {
             get { return new TimeSpan(TimeSpan.TicksPerHour); }
         }

         public static TimeSpan Sliding_Hour_2
         {
             get { return new TimeSpan(TimeSpan.TicksPerHour * ); }
         }

         public static TimeSpan Sliding_Hour_5
         {
             get { return new TimeSpan(TimeSpan.TicksPerHour * ); }
         }

         public static TimeSpan Sliding_Hour_12
         {
             get { return new TimeSpan(TimeSpan.TicksPerHour * ); }
         }

         public static TimeSpan Sliding_Day_1
         {
             get { return new TimeSpan(TimeSpan.TicksPerDay); }
         }
         #endregion

         /// <summary>
         /// 缓存
         /// </summary>
         private static Cache cache = HttpRuntime.Cache;

         /// <summary>
         /// 根据键获取缓存数据
         /// </summary>
         /// <param name="cacheKey">缓存的键</param>
         /// <returns></returns>
         private static object GetCache(string cacheKey)
         {
             return cache.Get(cacheKey);
         }

         /// <summary>
         ///  设置缓存
         /// </summary>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="objValue">缓存的值</param>
         private static void SetCache(string cacheKey, object objValue)
         {
             cache.Insert(cacheKey, objValue);
         }

         /// <summary>
         /// 设置缓存
         /// </summary>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="objValue">缓存的值</param>
         /// <param name="slidingExpiration">滑动过期时间</param>
         private static void SetCache(string cacheKey, object objValue, TimeSpan slidingExpiration)
         {
             cache.Insert(cacheKey, objValue, null, Cache.NoAbsoluteExpiration, slidingExpiration);
         }

         /// <summary>
         /// 设置缓存
         /// </summary>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="objValue">缓存的值</param>
         /// <param name="absoluteExpiration">绝对过期时间</param>
         private static void SetCache(string cacheKey, object objValue, DateTime absoluteExpiration)
         {
             cache.Insert(cacheKey, objValue, null, absoluteExpiration, Cache.NoSlidingExpiration);
         }

         /// <summary>
         /// 设置缓存
         /// </summary>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="objValue">缓存的值</param>
         /// <param name="dependency">文件依赖</param>
         private static void SetCache(string cacheKey, object objValue, CacheDependency dependency)
         {
             cache.Insert(cacheKey, objValue, dependency, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration);
         }

         /// <summary>
         /// 移除指定的缓存
         /// </summary>
         /// <param name="cacheKey">缓存的键</param>
         public static void Remove(string cacheKey)
         {
             cache.Remove(cacheKey);
         }

         /// <summary>
         /// 移除全部缓存
         /// </summary>
         public static void Remove()
         {
             IDictionaryEnumerator CacheEnum = cache.GetEnumerator();
             while (CacheEnum.MoveNext())
             {
                 Remove(CacheEnum.Key.ToString());
             }
         }

         /// <summary>
         /// 删除以cacheKeyPrefix为前缀的缓存Key的缓存
         /// </summary>
         /// <param name="cacheKeyPrefix">缓存键前缀</param>
         public static void RemoveByKeyStartsWith(string cacheKeyPrefix)
         {
             IDictionaryEnumerator CacheEnum = cache.GetEnumerator();
             while (CacheEnum.MoveNext())
             {
                 var key = CacheEnum.Key.ToString();
                 if (key != null && key.StartsWith(cacheKeyPrefix))
                 {
                     Remove(key);
                 }
             }
         }

         /// <summary>
         /// 从缓存中获取数据。缓存中不存在的时候，从回调方法getDate中获取，并设置进缓存。
         /// </summary>
         /// <typeparam name="T">缓存的数据类型</typeparam>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="getData">回调方法</param>
         /// <returns>缓存中的数据</returns>
         public static T Get<T>(string cacheKey, Func<T> getData)
         {
             var data = GetCache(cacheKey);
             if (data == null)
             {
                 data = getData();
                 SetCache(cacheKey, data);
             }
             return (T)data;
         }

         /// <summary>
         /// 从缓存中获取数据。缓存中不存在的时候，从回调方法getDate中获取，并设置进缓存。
         /// </summary>
         /// <typeparam name="T">缓存的数据类型</typeparam>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="slidingExpiration">滑动过期时间</param>
         /// <param name="getData">回调方法</param>
         /// <returns>缓存中的数据</returns>
         public static T Get<T>(string cacheKey, TimeSpan slidingExpiration, Func<T> getData)
         {
             var data = GetCache(cacheKey);
             if (data == null)
             {
                 data = getData();
                 SetCache(cacheKey, data, slidingExpiration);
             }
             return (T)data;
         }

         /// <summary>
         /// 从缓存中获取数据。缓存中不存在的时候，从回调方法getDate中获取，并设置进缓存。
         /// </summary>
         /// <typeparam name="T">缓存的数据类型</typeparam>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="absoluteExpiration">绝对过期时间</param>
         /// <param name="getData">回调方法</param>
         /// <returns>缓存中的数据</returns>
         public static T Get<T>(string cacheKey, DateTime absoluteExpiration, Func<T> getData)
         {
             var data = GetCache(cacheKey);
             if (data == null)
             {
                 data = getData();
                 SetCache(cacheKey, data, absoluteExpiration);
             }
             return (T)data;
         }

         /// <summary>
         /// 从缓存中获取数据。缓存中不存在的时候，从回调方法getDate中获取，并设置进缓存。
         /// </summary>
         /// <typeparam name="T">缓存的数据类型</typeparam>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="dependency">文件依赖</param>
         /// <param name="getData">回调方法</param>
         /// <returns>缓存中的数据</returns>
         public static T Get<T>(string cacheKey, CacheDependency dependency, Func<T> getData)
         {
             var data = GetCache(cacheKey);
             if (data == null)
             {
                 data = getData();
                 SetCache(cacheKey, data, dependency);
             }
             return (T)data;
         }

         /// <summary>
         /// 从缓存中获取数据。缓存中不存在的时候，从回调方法getDate中获取，并设置进缓存。
         /// </summary>
         /// <typeparam name="T">缓存的数据类型</typeparam>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="filename">依赖的文件路径</param>
         /// <param name="getData">回调方法</param>
         /// <returns>缓存中的数据</returns>
         public static T Get<T>(string cacheKey, string filename, Func<T> getData)
         {
             return Get<T>(cacheKey, new CacheDependency(filename), getData);
         }

         /// <summary>
         /// 从缓存中获取数据。缓存中不存在的时候，从回调方法getDate中获取，并设置进缓存。
         /// </summary>
         /// <typeparam name="T">缓存的数据类型</typeparam>
         /// <param name="cacheKey">缓存的键</param>
         /// <param name="filenames">依赖的文件路径</param>
         /// <param name="getData">回调方法</param>
         /// <returns>缓存中的数据</returns>
         public static T Get<T>(string cacheKey, string[] filenames, Func<T> getData)
         {
             return Get<T>(cacheKey, new CacheDependency(filenames), getData);
         }
     }
 }