【缓存】.net中Cache管理操作

隐藏行号 复制代码 这是一段程序代码。
  1. using System;
    
  2. using System.Web;
    
  3. using System.Web.Caching;
    
  4. using System.Collections;
    
  5. 
    
  6. /// <summary>
    
  7. /// 设置Cache操作类
    
  8. /// </summary>
    
  9. public class SetCache
    
  10. {
    
  11.     #region 用户自定义变量
    
  12.     private static readonly Cache _cache;//缓存实例
    
  13.     private static readonly int hourfactor;
    
  14.     #endregion
    
  15. 
    
  16.     #region 构造函数
    
  17.     static SetCache()
    
  18.     {
    
  19.         hourfactor = 3600;
    
  20.         _cache = HttpRuntime.Cache;
    
  21.     }
    
  22. 
    
  23.     private SetCache()
    
  24.     {
    
  25.     }
    
  26.     #endregion
    
  27. 
    
  28.     #region 清除所有缓存
    
  29.     /// <summary>
    
  30.     /// 清除所有缓存
    
  31.     /// </summary>
    
  32.     public static void Clear()
    
  33.     {
    
  34.         //要循环访问 Cache 对象的枚举数
    
  35.         IDictionaryEnumerator enumerator = _cache.GetEnumerator();//检索用于循环访问包含在缓存中的键设置及其值的字典枚举数
    
  36.         if (enumerator != null)
    
  37.         {
    
  38.             while (enumerator.MoveNext())
    
  39.             {
    
  40.                 _cache.Remove(enumerator.Key.ToString());
    
  41.             }
    
  42.         }
    
  43.     }
    
  44.     #endregion
    
  45. 
    
  46.     #region 得到缓存实例
    
  47.     /// <summary>
    
  48.     /// 得到缓存实例
    
  49.     /// </summary>
    
  50.     /// <param name="key">缓存实例名称</param>
    
  51.     /// <returns>返回缓存实例</returns>
    
  52.     public static object GetCache(string key)
    
  53.     {
    
  54.         return _cache[key];
    
  55.     }
    
  56.     #endregion
    
  57. 
    
  58.     #region 缓存实例插入
    
  59.     /// <summary>
    
  60.     /// 缓存实例插入(默认缓存20分钟)
    
  61.     /// </summary>
    
  62.     /// <param name="key">缓存实例名称</param>
    
  63.     /// <param name="obj">要缓存的对象</param>
    
  64.     public static void Insert(string key, object obj)
    
  65.     {
    
  66.         CacheDependency dep = null;
    
  67.         Insert(key, obj, dep, 20);
    
  68.     }
    
  69. 
    
  70.     /// <summary>
    
  71.     /// 缓存实例插入
    
  72.     /// </summary>
    
  73.     /// <param name="key">缓存实例名称</param>
    
  74.     /// <param name="obj">要缓存的对象</param>
    
  75.     /// <param name="seconds">缓存的时间</param>
    
  76.     public static void Insert(string key, object obj, int seconds)
    
  77.     {
    
  78.         CacheDependency dep = null;
    
  79.         Insert(key, obj, dep, seconds);
    
  80.     }
    
  81. 
    
  82.     /// <summary>
    
  83.     /// 缓存实例插入(缓存过期时间是一天)
    
  84.     /// </summary>
    
  85.     /// <param name="key">缓存实例名称</param>
    
  86.     /// <param name="obj">要缓存的对象</param>
    
  87.     /// <param name="dep">缓存的依赖项</param>
    
  88.     public static void Insert(string key, object obj, CacheDependency dep)
    
  89.     {
    
  90.         Insert(key, obj, dep, hourfactor * 12);
    
  91.     }
    
  92. 
    
  93.     /// <summary>
    
  94.     /// 缓存实例插入(缓存过期时间是一天)
    
  95.     /// </summary>
    
  96.     /// <param name="key">缓存实例名称</param>
    
  97.     /// <param name="obj">要缓存的对象</param>
    
  98.     /// <param name="xmlPath">缓存的依赖项xml文件的路径(绝对路径)</param>
    
  99.     public static void Insert(string key, object obj, string xmlPath)
    
  100.     {
    
  101.         CacheDependency dep = new CacheDependency(xmlPath);
    
  102.         Insert(key, obj, dep, hourfactor * 12);
    
  103.     }
    
  104. 
    
  105.     /// <summary>
    
  106.     /// 缓存实例插入
    
  107.     /// </summary>
    
  108.     /// <param name="key">缓存实例名称</param>
    
  109.     /// <param name="obj">要缓存的对象<</param>
    
  110.     /// <param name="seconds">缓存时间</param>
    
  111.     /// <param name="priority">该对象相对于缓存中存储的其他项的成本</param>
    
  112.     public static void Insert(string key, object obj, int seconds, CacheItemPriority priority)
    
  113.     {
    
  114.         Insert(key, obj, null, seconds, priority);
    
  115.     }
    
  116. 
    
  117.     /// <summary>
    
  118.     /// 缓存实例插入
    
  119.     /// </summary>
    
  120.     /// <param name="key">用于引用该对象的缓存键</param>
    
  121.     /// <param name="obj">要插入缓存中的对象</param>
    
  122.     /// <param name="dep">该项的文件依赖项或缓存键依赖项。当任何依赖项更改时,该对象即无效,并从缓存中移除。如果没有依赖项,则此参数包含空引用(Visual Basic 中为 Nothing)</param>
    
  123.     /// <param name="seconds">所插入对象将过期并被从缓存中移除的时间。</param>
    
  124.     public static void Insert(string key, object obj, CacheDependency dep, int seconds)
    
  125.     {
    
  126.         Insert(key, obj, dep, seconds, CacheItemPriority.Normal);
    
  127.     }
    
  128. 
    
  129.     /// <summary>
    
  130.     /// 缓存实例插入
    
  131.     /// </summary>
    
  132.     /// <param name="key">用于引用该对象的缓存键</param>
    
  133.     /// <param name="obj">要插入缓存中的对象</param>
    
  134.     /// <param name="xmlPath">缓存的依赖项xml文件的路径(绝对路径)</param>
    
  135.     /// <param name="seconds">所插入对象将过期并被从缓存中移除的时间。</param>
    
  136.     public static void Insert(string key, object obj, string xmlPath, int seconds)
    
  137.     {
    
  138.         CacheDependency dep = new CacheDependency(xmlPath);
    
  139.         Insert(key, obj, dep, seconds, CacheItemPriority.Normal);
    
  140.     }
    
  141. 
    
  142.     /// <summary>
    
  143.     /// 缓存实例插入
    
  144.     /// </summary>
    
  145.     /// <param name="key">用于引用该对象的缓存键</param>
    
  146.     /// <param name="obj">要插入缓存中的对象</param>
    
  147.     /// <param name="dep">该项的文件依赖项或缓存键依赖项。当任何依赖项更改时,该对象即无效,并从缓存中移除。如果没有依赖项,则此参数包含空引用(Visual Basic 中为 Nothing)。</param>
    
  148.     /// <param name="seconds">所插入对象将过期并被从缓存中移除的时间。</param>
    
  149.     /// <param name="priority">该对象相对于缓存中存储的其他项的成本,由 CacheItemPriority 枚举表示。该值由缓存在退出对象时使用;具有较低成本的对象在具有较高成本的对象之前被从缓存移除。 </param>
    
  150.     public static void Insert(string key, object obj, CacheDependency dep, int seconds, CacheItemPriority priority)
    
  151.     {
    
  152.         if (obj != null)
    
  153.         {
    
  154.             _cache.Insert(key, obj, dep, DateTime.Now.AddSeconds((double)seconds), TimeSpan.Zero, priority, null);
    
  155.         }
    
  156.     }
    
  157.     #endregion
    
  158. 
    
  159.     #region 移出单个缓存
    
  160.     /// <summary>
    
  161.     /// 移出单个缓存
    
  162.     /// </summary>
    
  163.     /// <param name="key">缓存实例名称</param>
    
  164.     public static void Remove(string key)
    
  165.     {
    
  166.         _cache.Remove(key);
    
  167.     }
    
  168. 
    
  169.     #endregion
    
  170. 
    
  171.     #region 得到所有使用的Cache键值
    
  172.     /// <summary>
    
  173.     /// 得到所有使用的Cache键值
    
  174.     /// </summary>
    
  175.     /// <returns>返回所有的Cache键值</returns>
    
  176.     public static ArrayList GetAllCacheKey()
    
  177.     {
    
  178.         ArrayList arrList = new ArrayList();
    
  179.         IDictionaryEnumerator enumerator = _cache.GetEnumerator();
    
  180.         if (enumerator != null)
    
  181.         {
    
  182.             while (enumerator.MoveNext())
    
  183.             {
    
  184.                 arrList.Add(enumerator.Key);
    
  185.             }
    
  186.         }
    
  187.         return arrList;
    
  188.     }
    
  189.     #endregion
    
  190. }
    

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。