#region 返¤¦Ì回?缓o存ä?广?告?表À¨ª
/// <summary>
/// 返¤¦Ì回?缓o存ä?广?告?表À¨ª
/// </summary>
/// <returns></returns>
public static DataTable GetAdTable()
{
//CacheHelper.ClearCache();
DataTable dt = null;
string keyName = "Advert";
dt = (DataTable)CacheHelper.GetCache(keyName);
if (null==dt)
{
dt = db.GetTable("SELECT AdID,AID,AdTarget,AdWidth,AdHeight,AdNum,AdDes,ADType FROM [dbo].[Advert]");
CacheHelper.AddCache(keyName, dt);
}
return dt;
}
#endregion
#region 返¤¦Ì回?一°?个?广?告?位?的Ì?部?分¤?相¨¤应®|信?息¡é
/// <summary>
/// 返¤¦Ì回?一°?个?广?告?位?的Ì?部?分¤?相¨¤应®|信?息¡é
/// </summary>
/// <param name="Aid">广?告?们?ID</param>
/// <returns>一°?个?广?告?位?对?象¨®</returns>
public static AdvertModel GetAdModel(int Aid)
{
AdvertModel tmpModel = null;
try
{
DataRow dr = GetAdTable().Select("AID="+Aid)[0];
if (dr != null)
{
tmpModel = new AdvertModel();
tmpModel.AdID = DBNull.Value.Equals(dr["AdID"]) ? 0 : (int)dr["AdID"];
tmpModel.AdHeight = DBNull.Value.Equals(dr["AdHeight"]) ? 0 : (int)dr["AdHeight"];
tmpModel.AdNum = DBNull.Value.Equals(dr["AdNum"]) ? 0 : (int)dr["AdNum"];
tmpModel.AdTarget = DBNull.Value.Equals(dr["AdTarget"]) ? "_bank" : dr["AdTarget"].ToString();
tmpModel.AdWidth = DBNull.Value.Equals(dr["AdWidth"]) ? 0 : (int)dr["AdWidth"];
tmpModel.ADType = DBNull.Value.Equals(dr["ADType"]) ? 0 : (int)dr["ADType"];
}
}
catch (Exception e)
{
}
return tmpModel;
}
#endregion
using System;
using System.Collections.Generic;
using System.Text;
using System.Web.Caching;
using System.Web;
namespace Pad.Common
{
public class CacheHelper
{
// private static CacheItemRemovedCallback callback = new CacheItemRemovedCallback(CacheItemCallBack);
public static AggregateCacheDependency GetDependency(string dependencyKey)
{
AggregateCacheDependency dependency = new AggregateCacheDependency();
string[] tables = System.Configuration.ConfigurationManager.AppSettings[dependencyKey].Split('-');
foreach (string table in tables)
{
dependency.Add(new SqlCacheDependency("mypads", table));
}
return dependency;
}
/// <summary>
/// 键¨¹值¦Ì表À¨ª
/// </summary>
public static List<string> cacheKeyList = new List<string>();
/// <summary>
/// 由®¨¦键¨¹值¦Ì返¤¦Ì回?缓o存ä?对?象¨®
/// </summary>
/// <param name="keyName">键¨¹值¦Ì</param>
/// <returns>缓o存ä?对?象¨®</returns>
public static object GetCache(string keyName)
{
if (string.IsNullOrEmpty(keyName)) return null;
return HttpRuntime.Cache.Get(keyName);
}
//<summary>
// 缓o存ä?对?象¨®
//</summary>
// <param name="keyName">键¨¹值¦Ì</param>
//<param name="value">对?象¨®</param>
//<param name="dependency">依°¨¤赖¤¦Ì集¡¥合?</param>
public static void AddCache(string keyName, object value,AggregateCacheDependency dependency)
{
if (string.IsNullOrEmpty(keyName) || null == value) return;
if (!cacheKeyList.Contains(keyName)) cacheKeyList.Add(keyName);
HttpRuntime.Cache.Add(keyName, value, dependency, DateTime.Now, TimeSpan.Zero, CacheItemPriority.Normal,null);
}
/// <summary>
/// 缓o存ä?对?象¨®
/// </summary>
/// <param name="keyName">键¨¹值¦Ì</param>
/// <param name="value">对?象¨®</param>
/// <param name="dependency">依°¨¤赖¤¦Ì集¡¥合?</param>
public static void AddCache(string keyName, object value)
{
if (string.IsNullOrEmpty(keyName) || null == value) return;
if (!cacheKeyList.Contains(keyName)) cacheKeyList.Add(keyName);
SqlCacheDependency sqlDependency =null;
string connStr = System.Configuration.ConfigurationManager.ConnectionStrings["conn"].ConnectionString;
try
{
sqlDependency = new SqlCacheDependency("mypads", keyName);
}
catch (DatabaseNotEnabledForNotificationException ex)
{
Logs("A、¡é"+ex.ToString()+ex.Message);
try
{
//string connStr = @"Data Source=tangself\SQLEXPRESS;Initial Catalog=pads;Integrated Security=SSPI";
SqlCacheDependencyAdmin.EnableNotifications(connStr);
}
catch ( UnauthorizedAccessException e)
{
Logs("B、¡é" + e.ToString() + e.Message);
}
}
catch (TableNotEnabledForNotificationException ec)
{
Logs("C、¡é" + ec.ToString() + ec.Message);
try
{
//string connStr = @"Data Source=tangself\SQLEXPRESS;Initial Catalog=pads;Integrated Security=SSPI";
SqlCacheDependencyAdmin.EnableTableForNotifications(connStr, keyName);
}
catch (System.Data.SqlClient.SqlException ex)
{
Logs("D、¡é" + ex.ToString() + ex.Message);
}
}
finally
{
HttpRuntime.Cache.Add(keyName, value, sqlDependency, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
}
}
/// <summary>
/// 移°?去¨£¤缓o存ä?对?象¨®
/// </summary>
/// <param name="keyName">键¨¹值¦Ì</param>
public static void RemoveCache(string keyName)
{
if (cacheKeyList.Contains(keyName)) cacheKeyList.Remove(keyName);
HttpContext.Current.Cache.Remove(keyName);
}
/// <summary>
/// 清?除y缓o存ä?
/// </summary>
public static void ClearCache()
{
foreach (string keyName in cacheKeyList)
{
HttpContext.Current.Cache.Remove(keyName);
}
cacheKeyList.Clear();
}
public static void Logs(string res)
{
string path = AppDomain.CurrentDomain.BaseDirectory+ "\\logs.txt";
if (!System.IO.File.Exists(path))
{
System.IO.File.Create(path);
}
// System.Web.HttpContext.Current.Response.Write("aaaaaaaaaa");
System.IO.FileStream fs = System.IO.File.Open(path,System.IO.FileMode.Append);
byte[] str = System.Text.UnicodeEncoding.GetEncoding("db2312").GetBytes(DateTime.Now.ToString() + "\r\n" + res + "\r\n");
fs.Write(str, 0,str.Length);
fs.Close();
// //res.ToString();
}
}
}
SqlCacheDependency数据库缓存依赖。
实现步骤：
下面就让我们看一下如何实现数据库缓存依赖功能：
第一步： 修改web.config，让项目启用SqlCacheDependency 。
将下列代码加入web.config的<system.web>节：
<caching><sqlCacheDependency enabled="true" pollTime="6000">
<databases><add name="codematic" connectionStringName="strcodematic" /></databases>
</sqlCacheDependency></caching>
这里的connectionStringName指定了在<connectionStrings>中添加的某一个连接字符串。name则是为该SqlCacheDependency起的名字，这个名字将在第3步中用到。
SqlCacheDependency类会自动完成对此配置节信息的读取以建立和数据库之间的联系。
注意：在<databases>节的<add name="codematic" connectionStringName="strcodematic" />中的name属性值必须System.Web.Caching.SqlCacheDependency("codematic", "P_Product"); 中的第一个参数（数据库名称）相一致。
第三步：在代码中使用缓存，并为其设置SqlCacheDependency依赖：
public static object GetCache(string CacheKey){
System.Web.Caching.Cache objCache = HttpRuntime.Cache;
return objCache[CacheKey];
}
public static void SetCache(string CacheKey, object objObject, CacheDependency dep){
System.Web.Caching.Cache objCache = HttpRuntime.Cache;
objCache.Insert(CacheKey,objObject,dep,Cache.NoAbsoluteExpiration,
Cache.NoSlidingExpiration, CacheItemPriority.Default,null);
}
protected void Page_Load(object sender, EventArgs e){
string CacheKey = "cachetest";
object objModel = GetCache(CacheKey);//从缓存中获取
if (objModel == null){
objModel = GetData();//把当前时间进行缓存
if (objModel != null){
SqlCacheDependency dep = new SqlCacheDependency("codematic", "P_Product");
SetCache(CacheKey, objModel, dep);//写入缓存
}
//查询数据
private DataSet GetData(){}
从以上代码可以看出，和文件依赖基本相同，只是在存放缓存SetCache时存入的依赖对象不同罢了。这里用的是SqlCacheDependency。其中，创建SqlCacheDependency的构造方法：
|
public SqlCacheDependency (string databaseEntryName,string tableName) |
databaseEntryName ：是在Web.config 文件的 caching 节的 sqlCacheDependency 的 databases 元素中定义的数据库的名称。
tableName ：与 SqlCacheDependency 关联的数据库表的名称。
这样，只有当P_Product表的内容发生变化时，查询操作才会重新查询数据更新缓存的内容，可以大大减少数据库的重复查询和提高系统的性能和运行效率。
采用SQLServer2005 Broker和SqlDependency类来提供数据更改通知(原创)
在SQLServer2005中，SQL Server Service Broker 用于创建会话以交换消息。 消息交换在目标和发起方这两端之间进行。
使用 SqlDependency 订阅查询通知是直接的：SqlDependency 对象将管理数据库中设置通知涉及到的复杂性。建立通知后，对象便会监视实现通知的基础数据库对象，当 SQL Server 创建查询通知时，将在应用程序中调用事件处理程序。
对于应用程序接收SQL Server Service Broker通知，只能获取到对应数据库表数据做了何种更新，而无法获取更新的数据，而我们却可以利用这个通知，来做缓存依赖，来达到缓存过期的目的。
使用 SqlDependency 订阅查询通知必须向SQL Server Service Broker提供制定规则的查询语句，一般来讲，必须是简单的sql查询语句（不能用*，不能用top，不能用函数，包括聚合函数，不能用子查询，包括where后的子查询，不能用外连接，自连接，不能用临时表，不能用变量，不能用视图，不能垮库，表名之前必须加类似dbo数据库所有者这样的前缀），
例如：select * from table1，select column1 from table1，select count(*) from table1 都是错误的sql查询语句，select column1 from dbo.table1 则是正确的语句。
以下以一个实际的例子(sqlDep项目)来说明如何使用ServerBroker和SqlDependency类来做缓存依赖，充分利用服务器资源和提高应用程序性能，并且封装以提供给开发人员最大的便利性，我们需要按照如下步骤操作：
1. 首先要在使用的数据库执行 ALTER DATABASE AdventureWorks SET ENABLE_BROKER 以启用该功能，执行时必须关闭所有可能锁表的操作和作业。
2. 打开sqlDep示例，运行ServiceBrokerTest.aspx以查看结果，查看代码。
3. 在现有应用程序中增加更改通知以及缓存机制。
a) 在webconfig<configuration>节中添加<connectionStrings>节，并配置连接字符串。
b) 在webconfig<system.web>节中添加
<caching>
<cache percentagePhysicalMemoryUsedLimit="60" privateBytesPollTime="00:05:00" />
</caching> (此项配置全局缓存设置，可选)
c) 建立数据访问层，如何封装编写不限，只要具有返回数据的方法即可。
d) 嵌入或者重写DaBase.cs中的protected virtual DataTable GetDataTable方法，具体请参考sqlDep示例，该方法提供自动响应程序表发生的更改，自动设定缓存机制，封装此方法后，对于开发人员，只需要按照以往开发习惯提供任意sql语句编写程序获取数据。
e) 继承DaBase类或自己编写具有protected virtual DataTable GetDataTable方法的类，并调用该方法，参见DaDimCustomer.cs。
以下我们以sqlDep做测试，以验证可行性及其性能：
我们以SqlServer2005自带的AdventureWorksDW数据库中的DimCustomer表为例，该表有29列，各种数据类型都有，18484行，7984KB数据，平均每行0.43KB。
我们以每次查询20页，查询该表的所有列作为测试。由于缓存的是查询结果，所以内存变化可以根据每次查询的数据量为基准，20行大小大约是8.6KB，缓存默认设置是允许使用服务器内存的90%，
假设对应的数据库表不做更新操作，假设Web服务器有1G的内存可使用缓存，
则可以缓存12万份不重复结果(这里没有计算.net本身每个数据实体，每个缓存相关数据所占有的空间，相对于数据而言可以忽略不计)，
缓存命中率大都集中在常用查询，例如商品列表第一页，某个商品分类第一页等，一旦有某个用户使用了查询，则其他用户可以不需要访问数据库即可得到所需数据。即使缓存如果超过了程序规定的最大数据，.net运行时也会自动随即清空缓存，这并不影响程序运行。
在SQL Server 2005上执行
ALTER DATABASE <DatabaseName> SET ENABLE_BROKER;语句让相应的数据库启用监听服务，以便支持SqlDependency特性。
3.编写global.asax文件,启动监听sql2005通知事件.
Application_Start 中：
string connStr =System.Configuration.ConfigurationManager.ConnectionStrings["connStr"].ConnectionString;
System.Web.Caching.SqlCacheDependencyAdmin.EnableNotifications(connStr);
string[] tables = System.Configuration.ConfigurationManager.AppSettings["CacheTables"].Split('-');
foreach (string table in tables){
System.Web.Caching.SqlCacheDependencyAdmin.EnableTableForNotifications(connStr, table);
}
System.Data.SqlClient.SqlDependency.Start(connStr);
void Application_End(object sender, EventArgs e){
System.Data.SqlClient.SqlDependency.Stop(System.Configuration.ConfigurationManager.ConnectionStrings["connStr"].ConnectionString);
}
4.编写数据访问代码.创建一个EmployeeData的类,代码如下
public class EmployeeData{
private HttpContext context;
public DataSet GetCacheData(){
context = HttpContext.Current;
DataSet cache =(DataSet) context.Cache["employee"];
if (cache == null){return GetData();}
else{return cache;}
}
public DataSet GetData(){
adp.Fill(ds);
context.Cache.Add("employee", ds, dep, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.Default, new CacheItemRemovedCallback(this.DataDiff));
return ds;
}
public void DataDiff(string key, object value, CacheItemRemovedReason reason){
Console.WriteLine("key:" + key);
GetData();
}
}
这里需要注意的是 select语句的写法, 不能使用 select * 的方式,一定要在表名前加架构名称 如我们这里的 dbo.employee.
SQL SERVER 7.0/2000/2005版本
正文
一、SQL SERVER 7.0/2000和SQL SERVER 2005的简介及比较
1.1 SQL SERVER 7.0/2000
SQL SERVER 7.0/2000没有提供内置的支持数据缓存依赖的功能，所以只能通过采用添加特定数据库表、触发器等方式，通过后台不断轮询数据库来检查数据更改。当在数据表上执行INSERT、UPDATE、 DELETE操作时将自动发出更改通知，所以只能监测到表级，具体到哪一行是没法跟踪的。
使用方法步骤：
1.1.1 使用aspnet_regsql命令行或SqlCacheDependencyAdmin来配置连接数据库。
1.1.1.1 ALTER DATABASE <DatabaseName> SET ENABLE_BROKER;
aspnet_regsql -S <server> -U sa -P sa -d <database> -ed 启动数据库的数据缓存依赖功能
aspnet_regsql -S <server> -U sa -P sa -d <database> -t <table> -et 启动数据表的数据缓存依赖功能
1.1.1.2
SqlCacheDependencyAdmin.EnableNotifications(connectionString); //启动数据库的数据缓存依赖功能
SqlCacheDependencyAdmin.EnableTableForNotifications(connectionString,table); //启用数据表缓存
推荐这段代码写在Global.asax的Application_Start方法中，以便应用程序启动的时候就启用数据库和数据表的缓存依赖功能。
1.1.2 配置Web.config
<sqlCacheDependency enabled="true" pollTime="10000">配置在<sytem.web>下的<caching>结点下，只有一个数据库的话不必指定下一级<database>结点
1.1.3 应用程序数据缓存中使用(还可以在数据源控件、输出缓存整个页面时使用，这里就不介绍了，下同)
SqlCacheDependency scd = new SqlCacheDependency("数据库名称","表名");
Cache.Insert(...,scd,...);
1.2 SQL SERVER 2005
内置支持SQL数据缓存依赖，内置通知传递服务，能够提供更小粒度的数据更改监测，使用和配置简单。
使用方法步骤：
1.2.1 检测是否已经启用Service Broker
Select DATABASEpRoPERTYEX('数据库名称','IsBrokerEnabled') -- 1 表示已经启用 0 表示没有启用
这个地方我看有些朋友翻译的成“是否能启用”，这是不对的，这里我把英文原文帖出来：“This can be checked by calling "Select databasepropertyex('db Name', 'IsBrokerEnabled')". A '1' means that the broker is enabled. A '0' means that the broker is not enabled. ”。
依据我的经验，如果直接在当前SqlServer2005上新建一个数据库的话，默认是打开的，如果是从其他地方数据库导过来的，导入之后默认关闭了。(可能有不准确，大家可以自己试验一下测试一下)。如果已经打开可直接调到1.2.2。
1.2.1.1 启用Service Broker
ALTER DATABASE 数据库名称 SET ENABLE_BROKER;
2009-5-26补充： 如果执行此语句超过10秒或处于假死状态，请重启数据库，什么都别做先执行这个语句就行了！
1.2.2 在实现基于服务的SQL数据缓存依赖过程中，需要显式调用SqlDependency.Start来启动接受依赖项更改通知的侦听器。
SqlDependency.Start(connectionString); //推荐将这段代码加到Global.asax的Application_Start方法中，
SqlDependency.Stop(connectionString); //用于关闭，可加在Global.asax的Application_End方法中。
1.2.3 应用程序数据缓存中使用
SqlCommand cmd = new SqlCommand(sql,conn);
SqlCacheDependency scd = new SqlCacheDependency(cmd);
Cache.Insert(...,scd,...);
注意:
a). 必须设置完全限定名称的数据表。即表名前面需要加所有者，如dbo.test。
b). 必须明确设置所访问数据库列名称，不能使用“*”。
c). 必须保证不是聚合函数。如COUNT、MAX等。
1.3 比较、区别
|
并且很明显，SQL SERVER 2005的缓存机制更加高效。另外，SqlCacheDependency类还特别结合SQL SERVER 2005 进行了优化:
a). 使用SQL SERVER 2005 时，SqlCacheDependency类支持与System.Data.SqlClient.SqlDependency类进行集成。应用程序可创建SqlDependency对象，并通过OnChanged事件处理程序接受通知进行注册。这样，应用程序不仅可以使用Sql server 2005的查询通知机制来监测使用SQL查询结果无效的数据更改，并将缓存对象从缓存中移除，而且还可以轻松获取数据更改通知，以便刷新缓存。(从这里可以看出，当触发onRemoveCallback委托的时候，数据已经从缓存里面删除了，这样一来可以手动在委托里面添加缓存，或者干脆设置成null，让他下次调用的时候再缓存。)
b). 不仅向应用程序添加缓存依赖项，还可以与@OutputCache指令一起使用，以生成依赖于SqlServer数据库表的输出缓存的页面或用户控件。对于用户控件，@OutputCache指令不支持使用SQL SERVER 2005 的查询通知(即onRemoveCallback委托)。
二、System.Web.Caching.Cache Insert和Add区别
2.1 Add方法
object Add(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback);
2.2 Insert方法
void Insert(string key, object value);
void Insert(string key, object value, CacheDependency dependencies);
void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration);
void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemUpdateCallback onUpdateCallback);
void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, CacheItemRemovedCallback onRemoveCallback);
2.3 比较、区别
a). Insert方法支持5种重载，使用灵活，而Add方法必须提供7个参数；
b). Add方法可以返回缓存项的数据对象，Insert 返回Void；
c). 添加重复缓存情况下，Insert会替换该项，而Add方法会报错。
三、 CacheDependency、AggregateCacheDependency、SqlCacheDependency
3.1 CacheDependency是AggregateCacheDependency和SqlCacheDependency的父类。主要用于在应用程序数据缓存对象与文件、缓存键、文件或缓存键的数组或另外一个CacheDependency对象之间建立依赖关系。CacheDependency监视依赖关系比便在任何对象更改时自动移除缓存对象。CacheDependency可以监测一组(到文件或目录的)文件路径的更改情况。
3.2 AggregateCacheDependency主要用于实现聚合缓存依赖。如一笔数据同时对两个表进行缓存依赖，一旦其中任何一个表数据更改缓存将失效。
3.3 SqlCacheDependency将应用程序数据缓存对象、页面输出缓存、数据源控件等与指定SQL Server数据库表或Sql Server 2005 查询结果之间建立缓存依赖关系，在表发生更改(Sql Server 2005 行级别更改)时，自动从缓存中删除和重新添加与该表关联的缓存对象。一般而言：
SqlCacheDependency (SqlCommand) 用于SQL SERVER 2005
SqlCacheDependency (数据库名, 表名) 用于SQL SERVER 7.0/2000
使用 SqlDependency 订阅查询通知必须向SQL Server Service Broker提供制定规则的查询语句，一般来讲，必须是简单的sql查询语句（不能用*，不能用top，不能用函数，包括聚合函数，不能用子查询，包括where后的子查询，不能用外连接，自连接，不能用临时表，不能用变量，不能用视图，不能垮库，表名之前必须加类似dbo数据库所有者这样的前缀），
例如：select * from table1，select column1 from table1，select count(*) from table1 都是错误的sql查询语句，select column1 from dbo.table1 则是正确的语句。
使用步骤
一 为数据库开启SqlCacheDependency功能
方法1：使用aspnet_regsql命令行或SqlCacheDependencyAdmin来配置连接数据库。
aspnet_regsql -S SQL服务器名 -E -d 数据库 -ed 启动数据库的数据缓存依赖功能
我们还需要对相关的数据表执行aspnet_regsql命令，如：
aspnet_regsql -S SQL服务器名 -E -d 数据库 -t 表名 -et 多个表就多次执行这句话
方法2：
SqlCacheDependencyAdmin.EnableNotifications(connectionString); //启动数据库的数据缓存依赖功能
SqlCacheDependencyAdmin.EnableTableForNotifications(connectionString, table); //启用数据表缓存
推荐这段代码写在Global.asax的Application_Start方法中，以便应用程序启动的时候就启用数据库和数据表的缓存依赖功能。
二 配置Web.config
<!--缓存配置-->
<caching>
<!--pollTime为查询数据库是否变动的间隔时间，毫秒单位-->
<sqlCacheDependency enabled="true" pollTime="10000">
<databases>
<add name="数据库名" connectionStringName="Webconfig的连接字符串key" pollTime="10000"/>
</databases>
</sqlCacheDependency>
</caching>
三 编码实现
缓存操作类：
/// <summary>
/// 获取所有相关配置并对应添加CacheDependency对象
/// </summary>
/// <param name="configKey">指定需要使用Cache的数据库表名的Webconfig's key</param>
/// <returns></returns>
public static AggregateCacheDependency GetDepandency(string configKey)
{
AggregateCacheDependency dependency = new AggregateCacheDependency();
string dbName = ConfigurationManager.AppSettings["CacheDatabaseName"];
string tableConfig = ConfigurationManager.AppSettings[configKey];
string[] tables = tableConfig.Split(',');
foreach (string tableName in tables)
dependency.Add(new SqlCacheDependency(dbName, tableName));
return dependency;
}
缓存业务类：
/// <summary>
/// 友情链接SqlCacheDependency类
/// </summary>
public class LinksProxy
{
/// <summary>
/// 设置缓存持续时间
/// </summary>
private static readonly int CacheTimeout = int.Parse(ConfigurationManager.AppSettings["LinksCacheDuration"]);
/// <summary>
/// 是否开启缓存
/// </summary>
private static readonly bool enableCaching = bool.Parse(ConfigurationManager.AppSettings["EnableCaching"]);
/// <summary>
/// 获取全部友情链接
/// </summary>
public static IList<LinksInfo> GetLinks()
{
//如果不开启缓存则直接调用DAL方法执行常规操作
if (!enableCaching)
return LinksDAL.SelectLinks();
else //开启缓存
{
//设置缓存key，这个最好根据查询条件来设置，这样可以缓存同一条件的数据
string key = "Links_by_search_all";
//读取缓存中的数据
IList<LinksInfo> data = (IList<LinksInfo>)HttpRuntime.Cache[key];
if (data == null)//如果缓存没有读到数据
{
//访问DAL从数据库读取数据并加入缓存，最后返回
data = LinksDAL.SelectLinks();
AggregateCacheDependency acd = TableCacheDependency.GetDepandency("LinksTableDependency");
HttpRuntime.Cache.Add(key, data, acd,DateTime.Now.AddMinutes(CacheTimeout), Cache.NoSlidingExpiration, CacheItemPriority.High, null);
}
return data;
}
}
}