C#缓存操作类

转载自某大神，可惜忘记原地址了。直接贴代码：

using System;
using System.Web;
using System.Web.Caching;
using System.Collections;

/// <summary>
///CacheOperate 的摘要说明
/// </summary>
public class CacheOperate
{
    #region 用户自定义变量
    private static readonly Cache _cache;//缓存实例
    private static readonly int hourfactor;//默认过期时间
    #endregion

    #region 构造函数
    static CacheOperate()
    {
        hourfactor = 1;
        _cache = HttpRuntime.Cache;
    }

    private CacheOperate()
    {
    }
    #endregion

    #region 清除所有缓存
    /// <summary>
    /// 清除所有缓存
    /// </summary>
    public static void Clear()
    {
        //要循环访问 Cache 对象的枚举数
        IDictionaryEnumerator enumerator = _cache.GetEnumerator();//检索用于循环访问包含在缓存中的键设置及其值的字典枚举数
        if (enumerator != null)
        {
            while (enumerator.MoveNext())
            {
                _cache.Remove(enumerator.Key.ToString());
            }
        }
    }
    #endregion

    #region 得到缓存实例
    /// <summary>
    /// 得到缓存实例
    /// </summary>
    /// <param name="key">缓存实例名称</param>
    /// <returns>返回缓存实例</returns>
    public static object GetCache(string key)
    {
        return _cache[key];
    }
    #endregion

    #region 缓存实例插入
    /// <summary>
    /// 缓存实例插入(默认缓存时间)
    /// </summary>
    /// <param name="key">缓存实例名称</param>
    /// <param name="obj">要缓存的对象</param>
    public static void Insert(string key, object obj)
    {
        CacheDependency dep = null;
        Insert(key, obj, dep, hourfactor);
    }

    /// <summary>
    /// 缓存实例插入
    /// </summary>
    /// <param name="key">缓存实例名称</param>
    /// <param name="obj">要缓存的对象</param>
    /// <param name="hours">缓存的时间</param>
    public static void Insert(string key, object obj, int hours)
    {
        CacheDependency dep = null;
        Insert(key, obj, dep, hours);
    }

    /// <summary>
    /// 缓存实例插入(默认缓存过期时间)
    /// </summary>
    /// <param name="key">缓存实例名称</param>
    /// <param name="obj">要缓存的对象</param>
    /// <param name="dep">缓存的依赖项</param>
    public static void Insert(string key, object obj, CacheDependency dep)
    {
        Insert(key, obj, dep, hourfactor);
    }

    /// <summary>
    /// 缓存实例插入(默认缓存过期时间)
    /// </summary>
    /// <param name="key">缓存实例名称</param>
    /// <param name="obj">要缓存的对象</param>
    /// <param name="xmlPath">缓存的依赖项xml文件的路径（绝对路径）</param>
    public static void Insert(string key, object obj, string xmlPath)
    {
        CacheDependency dep = new CacheDependency(xmlPath);
        Insert(key, obj, dep, hourfactor);
    }

    /// <summary>
    /// 缓存实例插入
    /// </summary>
    /// <param name="key">缓存实例名称</param>
    /// <param name="obj">要缓存的对象<</param>
    /// <param name="hours">缓存时间</param>
    /// <param name="priority">该对象相对于缓存中存储的其他项的成本</param>
    public static void Insert(string key, object obj, int hours, CacheItemPriority priority)
    {
        Insert(key, obj, null, hours, priority);
    }

    /// <summary>
    /// 缓存实例插入
    /// </summary>
    /// <param name="key">用于引用该对象的缓存键</param>
    /// <param name="obj">要插入缓存中的对象</param>
    /// <param name="dep">该项的文件依赖项或缓存键依赖项。当任何依赖项更改时，该对象即无效，并从缓存中移除。如果没有依赖项，则此参数包含空引用（Visual Basic 中为 Nothing）</param>
    /// <param name="hours">所插入对象将过期并被从缓存中移除的时间。</param>
    public static void Insert(string key, object obj, CacheDependency dep, int hours)
    {
        Insert(key, obj, dep, hours, CacheItemPriority.Normal);
    }

    /// <summary>
    /// 缓存实例插入
    /// </summary>
    /// <param name="key">用于引用该对象的缓存键</param>
    /// <param name="obj">要插入缓存中的对象</param>
    /// <param name="xmlPath">缓存的依赖项xml文件的路径（绝对路径）</param>
    /// <param name="hours">所插入对象将过期并被从缓存中移除的时间。</param>
    public static void Insert(string key, object obj, string xmlPath, int hours)
    {
        CacheDependency dep = new CacheDependency(xmlPath);
        Insert(key, obj, dep, hours, CacheItemPriority.Normal);
    }

    /// <summary>
    /// 缓存实例插入
    /// </summary>
    /// <param name="key">用于引用该对象的缓存键</param>
    /// <param name="obj">要插入缓存中的对象</param>
    /// <param name="dep">该项的文件依赖项或缓存键依赖项。当任何依赖项更改时，该对象即无效，并从缓存中移除。如果没有依赖项，则此参数包含空引用（Visual Basic 中为 Nothing）。</param>
    /// <param name="hours">所插入对象将过期并被从缓存中移除的时间。</param>
    /// <param name="priority">该对象相对于缓存中存储的其他项的成本，由 CacheItemPriority 枚举表示。该值由缓存在退出对象时使用；具有较低成本的对象在具有较高成本的对象之前被从缓存移除。 </param>
    public static void Insert(string key, object obj, CacheDependency dep, int hours, CacheItemPriority priority)
    {
        if (obj != null)
        {
            _cache.Insert(key, obj, dep, DateTime.Now.AddHours((double)hours), TimeSpan.Zero, priority, null);
        }
    }
    #endregion

    #region 移出单个缓存
    /// <summary>
    /// 移出单个缓存
    /// </summary>
    /// <param name="key">缓存实例名称</param>
    public static void Remove(string key)
    {
        _cache.Remove(key);
    }
    #endregion

    #region 得到所有使用的Cache键值
    /// <summary>
    /// 得到所有使用的Cache键值
    /// </summary>
    /// <returns>返回所有的Cache键值</returns>
    public static ArrayList GetAllCacheKey()
    {
        ArrayList arrList = new ArrayList();
        IDictionaryEnumerator enumerator = _cache.GetEnumerator();
        if (enumerator != null)
        {
            while (enumerator.MoveNext())
            {
                arrList.Add(enumerator.Key);
            }
        }
        return arrList;
    }
    #endregion

}

使用实例：

将xml对象存入缓存，当xml文件有改动时，缓存直接失效。

/// <summary>
/// 获取XML对象
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public static System.Xml.XmlDocument getXmlDoc(string path)
{
    System.Xml.XmlDocument xml = new System.Xml.XmlDocument();
    object cache = CacheOperate.GetCache(path);
    if (cache != null)
    {
        xml = cache as System.Xml.XmlDocument;
    }
    else
    {
        try
        {
            xml.Load(HttpContext.Current.Server.MapPath(path));
            CacheOperate.Insert(path, xml, HttpContext.Current.Server.MapPath(path));
        }
        catch (Exception) { }
    }

    return xml;
}