ASP.NETCache的使用

页面缓存：

在前台添加   <%@ OutputCache Duration="5"  VaryByParam="none" %> 标签

上述代码使用@OutputCatch指令声明了页面缓存，该页面将被缓存120秒。@OutputCatch指令包括10个属性，通过这些属性能够分别为页面的不同情况进行缓存设置，常用的属性如下所示：

q CacheProfile：获取或设置OutputCacheProfile名称。

q Duration：获取或设置缓存项需要保留在缓存中的时间。

q VaryByHeader：获取或设置用于改变缓存项的一组都好分隔的HTTP标头名称。

q Location：获取或设置一个值，该值确定缓存项的位置，包括Any、Clint、Downstream、None、Server和ServerAndClient。默认值为Any。

q VaryByControl：获取或设置一簇分好分隔的控件标识符，这些标识符包含在当前页或用户控件内，用于改变当前的缓存项。

q NoStore：获取或设置一个值，该值确定是否设置了“Http Cache-Control：no-store”指令。

q VaryByCustom：获取输出缓存用来改变缓存项的自定义字符串列表。

q Enabled：获取或设置一个值，该值指示是否对当前内容启用了输出缓存。

q VaryByParam：获取查询字符串或窗体POST参数的列表。

通过设置相应的属性，可以为页面设置相应的缓存，当需要为Default.aspx设置缓存项时，可以使用VaryByParam属性进行设置，示例代码如下所示。

<%@ OutputCache Duration="120" VaryByParam="none" %>

上述代码使用了Duration属性和VarByParam属性设置了当前页的缓存属性。为一个页面进行整体的缓存设置往往是没有必要的，常常还会造成困扰，例如Default.aspx?id=1和Default.aspx?id=100在缓存时可能呈现的页面是相同的，这往往不是开发人员所希望的。通过配置VarByParam属性能够指定缓存参数，示例代码如下所示。

<%@ OutputCache Duration="120" VaryByParam="id" %>

上述代码则通过参数id进行缓存，当id项不同时，ASP.NET所进行的页面缓存也不尽相同。这样保证了Default.aspx?id=1和Default.aspx?id=100在缓存时所显示的页面并不一致。VarByHeader和VarByCustom主要用于根据访问页面的客户端对页面的外观或内容进行自定义。在ASP.NET中，一个页面可能需要为PC用户和MOBILE用户呈现输出，因此可以通过客户端的版本不同来缓存不同的数据，示例代码如下所示。

<%@ OutputCache Duration="120" VaryByParam="none" VaryByCustom="browser" %>

自定义缓存：

 

protected void Button1_Click(object sender, EventArgs e)
        {
            Cache.Remove("title");
            Cache.Insert("", "", null, DateTime.Now.AddHours(1), TimeSpan.Zero);
            if (Cache["title"] == null)
            {
                string title = "查询数据库的操作"; //查询数据库的操作结果
                if (title != null)
                {
                    Button1.Text = title;
                    Cache["title"] = title;
                }
            }
            else
            {
                Button1.Text = Cache["title"].ToString();      
            }
        }

 

文件依赖缓存：

protected void Button2_Click(object sender, EventArgs e)
        {
            //Cache.Insert();
            //如果缓存中没有数据
            if (Cache["fmsg"] == null)
            {
                string path = Server.MapPath("~/a.txt");
                string msg = System.IO.File.ReadAllText(path);
                //创建文件依赖对象
                System.Web.Caching.CacheDependency cDep = new System.Web.Caching.CacheDependency(path);
                Cache.Add("fmsg", msg, cDep, System.Web.Caching.Cache.NoAbsoluteExpiration,
                    System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.Normal, RemoveCallback);
                Response.Write("刚才因为文件被修改所以缓存清空了，又创建了一个缓存，下次访问的时候就能看到了");
            }
            //缓存中有数据
            else
            {
                Response.Write("Cache['fmsg']=" + Cache["fmsg"].ToString());
            }
        }
        //回调函数   当数据清空的时候
        void RemoveCallback(string key, object value, System.Web.Caching.CacheItemRemovedReason reason)
        {
            string logPath = Server.MapPath("~/cache.log");
            System.IO.File.AppendAllText(logPath,"CacheDependency中，cache["+key+"]="+value.ToString()+"因为"+reason.ToString()+
                "被移除了");
        }

Cache  insert方法

 

protected void Button3_Click(object sender, EventArgs e)
        {
          //  为数据库中的表新建对应的表，表的标示码，版本号。
          //  为原来的表创建触发器，当发生改变的时候使版本号变化
            //配置web.config文件 等
            string msg = "数据库取出来的数据";     //查询数据库的操作结果
            System.Web.Caching.SqlCacheDependency sqlDep = new
                System.Web.Caching.SqlCacheDependency("依赖数据库名","依赖表名");
            Cache.Insert("fmsg", msg, sqlDep, System.Web.Caching.Cache.NoAbsoluteExpiration,
                    System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.Normal, RemoveCallback);
        }

 

数据源缓存

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data.SqlClient;
using System.Data;

namespace 缓存相关
{
    public partial class 数据源缓存 : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            ObjectDataSource obj = new ObjectDataSource();
            obj.EnableCaching = true;
            obj.CacheDuration = 20;
            obj.CacheExpirationPolicy = DataSourceCacheExpiry.Sliding;  //访问后就清空重新开始计数
            obj.CacheExpirationPolicy = DataSourceCacheExpiry.Absolute;  //累计访问计数
      
        }

        private string name;

        public void GetInfo()
        {
            SqlConnection conn = new SqlConnection();
            conn.Open();
            SqlCommand cmd = new SqlCommand("@",conn);
            SqlParameter[] parms = { 
                                   new SqlParameter("@",""),
                                    new SqlParameter("@","")
                                   };
            cmd.Parameters.AddRange(parms);
            SqlDataAdapter da = new SqlDataAdapter(cmd);
            DataTable dt = new DataTable();
            da.Fill(dt);
            if (dt.Rows.Count > 0)
            {
                DataBin(); 
            }
        }

        public void DataBin()
        { 
            //绑定操作
        }
    }
}

 

数据缓存代码：

using System;
using System.Web;
using System.Web.Caching;
using System.Collections;
using System.Text.RegularExpressions;

namespace ICS.NewOperationClass
{
    /// <summary>
    /// 设置Cache操作类
    /// </summary>
    public class SetCache
    {
        #region 用户自定义变量
        private static readonly Cache _cache;//缓存实例
        private static readonly int hourfactor;
        #endregion

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

        private SetCache()
        {
        }
        #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>
        /// 缓存实例插入(默认缓存20分钟)
        /// </summary>
        /// <param name="key">缓存实例名称</param>
        /// <param name="obj">要缓存的对象</param>
        public static void Insert(string key, object obj)
        {
            CacheDependency dep = null;
            Insert(key, obj, dep, 20);
        }

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

        /// <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 * 12);
        }

        /// <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 * 12);
        }

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

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

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

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

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

        #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
    }
}