Asp.Net缓存（1）

知其根本，方能应用。MSDN上的缓存讲解。先看原来讲解。

Asp.Net缓存概述

通常，应用程序可以将那些频繁访问的数据，以及那些需要大量处理时间来创建的数据存储在内存中，从而提高性能。

在这些情况下，为了帮助您提高应用程序的性能，ASP.NET 使用两种基本的缓存机制来提供缓存功能。

第一种机制是应用程序缓存，它允许您缓存所生成的数据，如DataSet或自定义报表业务对象。

第二种机制是页输出缓存，它保存页处理输出，并在用户再次请求该页时，重用所保存的输出，而不是再次处理该页。

应用程序缓存

应用程序缓存提供了一种编程方式，可通过键/值对将任意数据存储在内存中。使用应用程序缓存与使用应用程序状态类似。但是，与应用程序状态不同的是，应用程序缓存中的数据是易失的，即数据并不是在整个应用程序生命周期中都存储在内存中。使用应用程序缓存的优点是由 ASP.NET 管理缓存，它会在项过期、无效、或内存不足时移除缓存中的项。还可以配置应用程序缓存，以便在移除项时通知应用程序。

使用应用程序缓存的模式是，确定在访问某一项时该项是否存在于缓存中，如果存在，则使用。如果该项不存在，则可以重新创建该项，然后将其放回缓存中。这一模式可确保缓存中始终有最新的数据。

页输出缓存

页输出缓存在内存中存储处理后的 ASP.NET 页的内容。这一机制允许 ASP.NET 向客户端发送页响应，而不必再次经过页处理生命周期。页输出缓存对于那些不经常更改，但需要大量处理才能创建的页特别有用。例如，如果创建大通信量的网页来显示不需要频繁更新的数据，页输出缓存则可以极大地提高该页的性能。可以分别为每个页配置页缓存，也可以在Web.config 文件中创建缓存配置文件。利用缓存配置文件，只定义一次缓存设置就可以在多个页中使用这些设置。

页输出缓存提供了两种页缓存模型：整页缓存和部分页缓存。整页缓存允许将页的全部内容保存在内存中，并用于完成客户端请求。部分页缓存允许缓存页的部分内容，其他部分则为动态内容。

部分页缓存

可采用两种工作方式：控件缓存和缓存后替换。控件缓存有时也称为分段缓存，这种方式允许将信息包含在一个用户控件内，然后将该用户控件标记为可缓存的，以此来缓存页输出的部分内容（注：常见的如Asp.Net控件）。这一方式可缓存页中的特定内容，并不缓存整个页，因此每次都需重新创建整个页。例如，如果要创建一个显示大量动态内容（如股票信息）的页，其中有些部分为静态内容（如每周总结），这时可以将静态部分放在用户控件中，并允许缓存这些内容。

缓存后替换与控件缓存正好相反。这种方式缓存整个页，但页中的各段都是动态的。例如，如果要创建一个在规定时间段内为静态的页，则可以将整个页设置为进行缓存。如果向页添加一个显示用户名的Label控件，则对于每次页刷新和每个用户而言，Label的内容都将保持不变，始终显示缓存该页之前请求该页的用户的姓名。但是，使用缓存后替换机制，可以将页配置为进行缓存，但将页的个别部分标记为不可缓存(注：神奇)。在此情况下，可以向不可缓存部分添加Label控件，这样将为每个用户和每次页请求动态创建这些控件。

根据请求参数缓存页

除缓存页的单一版本外，ASP.NET 页输出缓存还提供了一些功能，可以创建根据请求参数的不同而不同的页的多个版本。

自动移除数据

出于以下原因之一，ASP.NET 可以从缓存中移除数据：

• 由于服务器上的内存不足，开始一个称为“清理”的过程。
• 由于缓存中的项已过期。
• 由于项的依赖项发生了更改。

为了帮助管理缓存项，在将项从缓存中移除时，ASP.NET 会通知应用程序。

缓存Asp.Net页

ASP.NET 使您可以缓存 ASP.NET 页所生成的部分响应或所有响应，在 ASP.NET 中将这种技术称为输出缓存。可以在发出请求的浏览器、响应请求的 Web 服务器以及请求或响应流中任何其他具有缓存功能的设备（如代理服务器）上缓存页。缓存为您提供了一个强有力的方式来提高 Web 应用程序的性能。缓存功能允许利用缓存满足对页的后续请求，这样就不需要再次运行最初创建该页的代码。对站点中访问最频繁的页进行缓存可以充分地提高 Web 服务器的吞吐量（通常以每秒的请求数计算）。

可以在页或配置文件中以声明方式或者通过编程方式使用缓存 API 指定缓存设置。

页面输出缓存配置

• 配置文件 可以在应用程序配置层次结构的任何配置文件中配置页面输出缓存设置，包括 Machine.config 文件（用于设置计算机上所有的 Web 应用程序）和特定于应用程序的 Web.config 文件（用于设置单个应用程序）。
• 单个页面 可以在单个页面中以声明方式或编程方式设置缓存选项。还可将在配置文件中创建的缓存配置文件应用于单个页面。
• 用户控件 可以在单个用户控件中以声明方式或编程方式设置缓存。对于在其他情况下不缓存的页面内容来说，这是一种简便的缓存方法。

Web.config 缓存配置设置

在 Web.config 文件中，有两个顶级配置节可用于页输出缓存：OutputCacheSection 和OutputCacheSettingsSection。

OutputCacheSection 节用于配置应用程序范围的设置，例如是启用还是禁用页输出缓存。例如，您可以通过向 Web.config 文件中的 OutputCacheSection 添加 enableOutputCache="false" 来对整个应用程序禁用页输出缓存。由于配置文件中的设置要优先于单个页面中的缓存设置，因此，示例设置将导致不使用输出缓存。

OutputCacheSettingsSection 用于配置可由单个页使用的配置文件和依赖项。例如，下面的代码创建了一个名为 CacheProfile1 的 OutputCacheProfile，它将缓存实现页 60 秒：

<outputCacheSettings>

<outputCacheProfiles>

<add name="CacheProfile1" duration="60" />

</outputCacheProfiles>

</outputCacheSettings>

Machine.config 缓存配置设置

Machine.config 文件的配置节与 Web.config 文件的配置节基本相同，而只有一点区别：即可以锁定 Machine.config 文件中的配置设置，使任何级别的单个应用程序都无法重写这些配置设置。在宿主不希望单个应用程序修改缓存配置时，可能有必要在共享宿主方案中使用此功能。

设置页的可缓存性

页或用户控件的可缓存性是指是否可以在页的响应生命周期内在设备上缓存页。可缓存页的设备包括发出请求的浏览器、响应请求的 Web 服务器以及请求或响应流中其他任何具有缓存功能的设备，如代理服务器。

当 Web 服务器向请求浏览器发送响应时，服务器会在响应的 HTTP 头中包含一个 Cache-Control 字段，该字段定义可以缓存该页的设备。根据您应用程序的需要，可以分别定义哪些设备应该或不应缓存各个 ASP.NET 页。例如，您可能希望用户登录页的可缓存性设置不同于显示产品选择的目录页的对应设置。对于登录页，出于安全方面的考虑，您可能希望只将页缓存到服务器上，而目录页可以缓存到任何设备上。

对于 ASP.NET 页，可以使用 HttpCacheability 枚举中的值设置可缓存性。该枚举具有下列值。前三个值与Cache-Control HTTP 头设置直接对应，后三个值为特殊值。

• NoCache 指定发出请求的设备每次应从 Web 服务器获取响应。
• Public 允许由客户端和共享（代理）缓存来缓存响应。
• Private 指定响应只能在客户端上缓存，而不能由共享（代理服务器）缓存来缓存。
• Server 指定仅在原始服务器上缓存响应。
• ServerAndNoCache 应用 Server 和 NoCache 两者的设置，以指示在该服务器上缓存内容，但显式拒绝其他所有服务器缓存响应的功能。
• ServerAndPrivate 指定仅在原始服务器和请求客户端上缓存响应；不允许代理服务器缓存响应。

您可以通过在 @ OutputCache 指令中包含 Location 属性并指定 OutputCacheLocation 枚举值之一，以声明的方式设置页的可缓存性。

还可以使用 SetCacheability 方法为页指定 HttpCacheability 值，从而以编程方式设置该页的可缓存性。

可以通过 Response 类的 Cache 属性访问该方法。

注意

如果您使用 @ OutputCache 指令设置页的可缓存性，则必须声明 Duration 属性，另外还必须声明VaryByControl 属性，或同时声明 VaryByParam 属性和 Location 属性。必须将 Duration 属性设置为大于零的值。如果不希望使用 VaryByParam 或 VaryByControl 参数的功能，可以将 VaryByParam 属性设置为“None”。

作为使用 @ OutputCache 指令设置页可缓存性的替换方法，可以在应用程序的 Web.config 文件中创建缓存配置文件，然后在页中引用该配置文件。

用户控件缓存配置设置

用户控件就是一个页面和普通页面缓存方式差不多。具体看后面。

缓存 API 配置设置

可以在 Web.config 文件中配置应用程序的缓存 API。

对于页面输出缓存，应用程序宿主可以在 Machine.config 文件中设置配置属性，并锁定所有应用程序的缓存配置设置。

应用程序缓存 API 在CacheSection中进行配置。例如，您可以使用下面的配置元素来禁用项过期：<cache disableExpiration="true" />

还可以通过为属性（如配置文件的CacheSection中的DisableExpiration和DisableMemoryCollection属性）赋值的方式来指定其他应用程序缓存 API 配置设置。

当用户请求某一缓存页时，ASP.NET 根据已经为该页定义的缓存策略确定其缓存输出是否仍有效。如果该输出有效，则将该缓存输出发送到客户端，并且不重新处理该页。ASP.NET 允许您在此验证检查期间运行代码，以便可以编写用于检查页是否有效的自定义逻辑。

有时，缓存整个页是不切实际的，因为在每次请求时可能需要更改页的某些部分。在这些情况下，可以缓存页的一部分。ASP.NET 提供了只缓存 ASP.NET 页的几部分的功能。

如何：以声明方式设置 ASP.NET 页的可缓存性

某页或用户控件的可缓存性指某页能否在其响应生命周期内缓存到某个设备上。这些设备包括发出请求的客户端（浏览器），响应请求的 Web 服务器，以及请求或响应流中任何具有缓存功能的设备（例如代理服务器）。

如果您在设计时知道某页需要什么样的可缓存性设置，您可以以声明方式设置可缓存性。该页将为所有请求使用相同的可缓存性设置。

以声明方式设置页的可缓存性

1. 在页中包含 @ OutputCache 指令，并定义 Duration 和 VaryByParam 属性。
2. 在@ OutputCache指令中包含 Location 属性，并将其值定义为 OutputCacheLocation 枚举中的下列值之一：Any、Client、Downstream、Server、ServerAndClient 或 None。

下面的代码演示如何将页的可缓存性设置为 60 秒：

<%@ OutputCache Duration="60" VaryByParam="None"%>

注意

默认设置为Any。如果未定义Location属性，则可以将页输出缓存在与响应有关的所有具有缓存功能的网络设备上。其中包括请求客户端、原服务器、以及响应通过的任何代理服务器。

使用缓存配置文件以声明方式设置页的可缓存性

1. 在应用程序的 Web.config 文件中定义缓存配置文件，在配置文件中包括duration和varyByParam设置。

下面的<caching>配置元素定义名为 Cache30Seconds 的缓存配置文件，它将在服务器上将页缓存 30 秒之久。

<caching>

<outputCacheSettings>

<outputCacheProfiles>

<add name="Cache30Seconds" duration="30"

varyByParam="none" />

</outputCacheProfiles>

</outputCacheSettings>

</caching>

1. 在使用配置文件的每个 ASP.NET 页中包含 @ OutputCache 指令，并将CacheProfile 属性设置为 Web.config 文件中定义的缓存配置文件的名称。

下面的代码指定页应当使用名为 Cache30Seconds 的缓存配置文件：

<%@ OutputCache CacheProfile="Cache30Seconds" %>

以声明方式为页设置输出缓存到期时间

将 @ OutputCache 指令包括在您要缓存其响应的 ASP.NET 页（.aspx 文件）中。将 Duration 属性设置为一个正数值，将 VaryByParam 属性设置为一个值。例如，将缓存设置为60秒：<%@ OutputCache Duration="60" VaryByParam="None" %>

注意 :1.默认情况下，@ OutputCache 指令将 Cache-Control 标头设置为 Any。

2.在使用 @ OutputCache 指令时，必须包括一个 VaryByParam 属性，否则将出现分析器错误。如果不希望使用 VaryByParam 属性提供的功能，请将它的值设置为“None”。

如何：以编程方式设置页的可缓存性

页或用户控件的可缓存性指的是某一页是否能在该页的响应生命周期内缓存在某个设备上。缓存页的这些设备包括发出请求的浏览器，响应请求的 Web 服务器，以及请求或响应流中任何可执行缓存的设备，如代理服务器。

如果应用程序将根据运行时条件（如读取请求标头）确定可缓存性，您可以通过编程方式设置可缓存性。

以编程方式设置页的可缓存性

• 在页的代码中，调用Response对象的Cache属性的SetCacheability方法。

下面的代码将Cache-Control HTTP 标头设置为Public。

C#

Response.Cache.SetCacheability(HttpCacheability.Public);

如果将NoCache或ServerAndNoCache传递到SetCacheability方法以防止请求的浏览器在它自己的历史记录文件夹中缓存某一页，那么任何时候当某个用户单击“后退”或“前进”按钮时，都会请求响应的新版本。通过调用Cache属性的SetAllowResponseInBrowserHistory方法，并且为allow参数传递true值，您可以按条件重写此行为。

如果将可缓存性设置为除NoCache或ServerAndNoCache之外的任何值，ASP.NET 将忽略由SetAllowResponseInBrowserHistory方法设置的值。

以编程方式为页设置输出缓存到期时间

在该页的代码中，在 Response 对象的 Cache 属性中设置该页的到期策略。

如果以编程方式设置页的到期时间，则您还必须为缓存的页设置 Cache-Control 标头。为此，请调用 SetCacheability 方法并向其传递 HttpCacheability 枚举值 Public。

下面的代码示例设置与前面过程中的 @ OutputCache 指令相同的缓存策略。

Response.Cache.SetExpires(DateTime.Now.AddSeconds(60));

Response.Cache.SetCacheability(HttpCacheability.Public);

Response.Cache.SetValidUntilExpires(true);

当缓存页到期时，以后对该页的请求将导致动态生成的响应。会在指定的持续时间内缓存该响应页。

如何：检查缓存页的有效性

用户请求缓存页时，ASP.NET 根据您在该页中定义的缓存策略来确定缓存输出是否仍然有效。如果缓存输出有效，则将输出发送到客户端，并且不重新处理该页。但是，ASP.NET 提供了使用验证回调在该验证检查期间运行代码的功能，因此您可以编写自定义逻辑来检查该页是否有效。利用验证回调，可以使在使用缓存依赖项的正常进程之外的缓存页无效。

以编程方式检查缓存页的有效性

1. 定义 HttpCacheValidateHandler 类型的事件处理程序，并包括检查缓存页响应的有效性的代码。

验证处理程序必须返回下列 HttpValidationStatus 值之一：

• Invalid   指示缓存页无效，将从缓存中移除该页，并且该请求将被作为缓存未命中处理。
• IgnoreThisRequest   导致将请求视为缓存未命中处理。因此，将重新处理该页，但不会使缓存页无效。
• Valid   指示缓存页有效。

下面的代码示例阐释名为 ValidateCacheOutput 的验证处理程序，该处理程序确定查询字符串变量 status 包含值“invalid”还是“ignore”。如果状态值为“invalid”，则该方法返回Invalid，并且使该页在缓存中无效。如果状态值为“ignore”，则该方法返回IgnoreThisRequest，并且该页仍保留在缓存中，但为该请求生成一个新响应。

public static void ValidateCacheOutput(HttpContext context, Object data,ref HttpValidationStatus status)

{

    if (context.Request.QueryString["Status"] != null)

{

//注意此处代码，值肯能是ivalid、ignore、Valid

        string pageStatus = context.Request.QueryString["Status"];

        if (pageStatus == "invalid")

            status = HttpValidationStatus.Invalid;

        else if (pageStatus == "ignore")

            status = HttpValidationStatus.IgnoreThisRequest;

        else

            status = HttpValidationStatus.Valid;

    }

    else

        status = HttpValidationStatus.Valid; //没有缓存，新建的都为Valid

}

1. 从其中一个页生命周期事件（如页的 Load 事件）中调用 AddValidationCallback 方法，将您在步骤 1 中定义的事件处理程序作为第一个参数传递。

下面的代码示例将 ValidateCacheOutput 方法设置为验证处理程序

protected void Page_Load(object sender, EventArgs e)

{

    Response.Cache.AddValidationCallback(

        new HttpCacheValidateHandler(ValidateCacheOutput),  null);

}

如何：使用文件依赖项缓存页输出

有时候，您可能需要在文件发生更改时从输出缓存中移除某一页。例如，您可能有这样一页：该页从生成 XML 文件作为输出且占用大量进程的报告中获取其内容。仅当 XML 文件发生更改时，才需要重新处理该页。要将重新处理限制为仅在需要的时候进行，可以使页的缓存策略依赖于单个文件。如有必要，可以使缓存页依赖于多个文件。

注意

通过调用 RemoveOutputCacheItem 方法，可显式移除输出缓存中的任何页。可以从 Global.asax 文件、自定义 ASP.NET 服务器控件或页中执行此操作，具体取决于应用程序的需要。

使缓存页输出依赖于一个文件

1. 以声明方式或编程方式指定缓存页输出的设置。
2. 在页代码中调用AddFileDependency方法。将创建依赖项的文件的路径作为方法的 filename 参数传递。

下面的代码示例在 TextFile1.txt 文件上设置一个文件依赖项。当文件发生更改时，将从缓存中移除页输出。

protected void Page_Load(object sender, EventArgs e)  //此处是编程方式声明，仅当此文件改变时，才需要重新处理该页，所以没必要判断是否是第一次处理。

{

    string fileDependencyPath = Server.MapPath("TextFile1.txt");

    Response.AddFileDependency(fileDependencyPath);//创建依赖项的文件

    // Set additional properties to enable caching.

    Response.Cache.SetExpires(DateTime.Now.AddSeconds());

    Response.Cache.SetCacheability(HttpCacheability.Public);

    Response.Cache.SetValidUntilExpires(true);

}

注意：不能从 ASP.NET 用户控件使用这些方法。但是，在指定 @ OutputCache 指令的任何用户控件中，您都可以创建一个文件依赖项，并将其分配给Dependency属性。

使缓存页输出依赖于文件组

以声明方式或编程方式指定缓存页输出的设置。

在页代码中，创建一个包含该页所要依赖的文件的路径的 String 数组或 ArrayList。调用 AddFileDependencies 方法，并将数组作为 filenames 参数传递。

下面的代码示例创建包含 TextFile1.txt 和 XMLFile1.xml 文件的文件路径的字符串数组，并使页输出依赖于这两个文件。如果修改了其中任何一个文件，将从缓存中移除页输出。

protected void Page_Load(object sender, EventArgs e)

{

    string[] fileDependencies;

    string fileDependency1 = Server.MapPath("TextFile1.txt");

    string fileDependency2 = Server.MapPath("XMLFile1.xml");

    fileDependencies = new String[] { fileDependency1,

        fileDependency2 };

Response.AddFileDependencies(fileDependencies);//其实和依赖一个文件一样，只是AddFileDependency变成AddFileDependencies而已，单数变复数。

}

如何：使用缓存键依赖项缓存页输

有时，当缓存中的某一项被移除时，您可能需要从输出缓存中移除一页。例如，您可能使用一页来显示放置在应用程序缓存中并供多个页使用的占用大量进程的报告。当该报告已更改或已从缓存中移除时，您希望将页输出也从缓存中移除，因为该报告不再有效。为此，可使缓存的页输出依赖于其他缓存项。

使缓存的页输出依赖于另一缓存项

1. 在页中，以声明方式或编程方式指定缓存设置。
2. 在页代码中调用 AddCacheItemDependency方法。将创建依赖项的缓存项的名称作为 cacheKey 参数传递

下面的代码示例演示如何在名为 ProcessIntensiveReport 的项上设置依赖项。当此项被修改或移除时，将从缓存中移除页输出。

protected void Page_Load(object sender, EventArgs e)

{

    Response.AddCacheItemDependency("ProcessIntensiveReport");

    // Set additional properties to enable caching.

    Response.Cache.SetExpires(DateTime.Now.AddSeconds());

    Response.Cache.SetCacheability(HttpCacheability.Public);

    Response.Cache.SetValidUntilExpires(true);

}

注意：

不能在 ASP.NET 用户控件中调用 AddCacheItemDependency 方法。不过，在指定 @ OutputCache 指令的任何用户控件中，都可以创建描述缓存键依赖项的 CacheDependency 对象，并将其分配给 UserControl 对象的 Dependency 属性。

缓存应用程序数据

ASP.NET 为您提供了一个强大的、便于使用的缓存机制，用于将需要大量服务器资源来创建的对象存储在内存中。缓存这些类型的资源会大大改进应用程序的性能。

缓存是由 Cache 类实现的；缓存实例是每个应用程序专用的。缓存生存期依赖于应用程序的生存期；重新启动应用程序后，将重新创建 Cache 对象。

设计 Cache 类是为了便于使用。您可以将项放置在 Cache 中，并在以后使用简单的键/值对来检索这些项。

Cache 类提供了强大的功能，允许您自定义如何缓存项以及将它们缓存多长时间。例如，当缺乏系统内存时，缓存会自动移除很少使用的或优先级较低的项以释放内存。该技术也称为清理，这是缓存确保过期数据不使用宝贵的服务器资源的方式之一。

当执行清理时，您可以指示 Cache 给予某些项比其他项更高的优先级。若要指示项的重要性，可以在使用 Add 或 Insert 方法添加项时指定一个 CacheItemPriority 枚举值。

当使用 Add 或 Insert 方法将项添加到缓存时，您还可以建立项的过期策略。您可以通过使用DateTime 值指定项的确切过期时间（绝对过期时间），来定义项的生存期。也可以使用 TimeSpan 值指定一个弹性过期时间，弹性过期时间允许您根据项的上次访问时间来指定该项过期之前的运行时间。一旦项过期，便将它从缓存中移除。试图检索它的值的行为将返回 null（在 Visual Basic 中为 Nothing），除非该项被重新添加到缓存中。

对于存储在缓存中的易失项（例如那些定期进行数据刷新的项或那些只在一段时间内有效的项），通常设置一种过期策略：只要这些项的数据保持为最新的，就将它们保留在缓存中。例如，如果您正在编写一个应用程序，该应用程序通过另一个网站获取数据来跟踪体育比赛的比分，那么只要源网站上比赛的比分不更改，就可以缓存这些比分。在此情况下，您可以根据其他网站更新比分的频率来设置过期策略。您可以编写代码来确定缓存中是否是最新的比分。如果该比分不是最新的，则代码可以从源网站读取比分并缓存新值。

最后，ASP.NET 允许您根据外部文件、目录（文件依赖项）或另一个缓存项（键依赖项）来定义缓存项的有效性。如果具有关联依赖项的项发生更改，缓存项便会失效并从缓存中移除。您可以使用该技术在项的数据源更改时从缓存中移除这些项。例如，如果您编写一个处理 XML 文件中的财务数据的应用程序，则可以从该文件将数据插入缓存中并在此 XML 文件上保留一个依赖项。当该文件更新时，从缓存中移除该项，您的应用程序重新读取 XML 文件，然后将刷新后的数据放入缓存中。

注意：Cache对象没有关于它所包含项的内容的信息。它只保留对这些对象的引用。它还提供跟踪它们的依赖项和设置到期策略的方法。

如何：将项添加到缓存中

可以使用Cache对象访问应用程序缓存中的项。可以使用Cache对象的Insert方法向应用程序缓存添加项。该方法向缓存添加项，并且通过几次重载，您可以用不同选项添加项，以设置依赖项、过期和移除通知。如果使用Insert方法向缓存添加项，并且已经存在与现有项同名的项，则缓存中的现有项将被替换。

还可以使用Add方法向缓存添加项。使用此方法，您可以设置与Insert方法相同的所有选项；然而，Add方法将返回您添加到缓存中的对象。另外，如果使用Add方法，并且缓存中已经存在与现有项同名的项，则该方法不会替换该项，并且不会引发异常。

本主题中的过程阐释了向应用程序缓存添加项的如下方式：

• 通过键和值直接设置项，向缓存添加项。
• 使用Insert方法向缓存添加项。
• 通过调用Add方法添加项。
• 向缓存添加项并添加依赖项，以便当该依赖项更改时，将该项从缓存中移除。可以基于其他缓存项、文件和多个对象设置依赖项。
• 将设有过期策略的项添加到缓存中。除了能设置项的依赖项以外，还可以设置项在一段时间以后（弹性过期）或在指定时间（绝对过期）过期。您可以定义绝对过期时间或弹性过期时间，但不能同时定义两者。
• 向缓存添加项，并定义缓存的项的相对优先级。相对优先级帮助 .NET Framework 确定要移除的缓存项；较低优先级的项比较高优先级的项先从缓存中移除。

除了这里显示的依赖项，可以在 SQL Server 表上或基于自定义依赖项创建依赖项。当从缓存中移除项时，还可以使用CacheItemRemovedCallback委托让应用程序缓存通知应用程序。

通过键和值直接设置项向缓存添加项

通过指定项的键和值，像将项添加到字典中一样将其添加到缓存中。

下面的代码示例将名为CacheItem1的项添加到Cache对象中：

        Cache["CacheItem1"] = "Cached Item 1";

通过使用 Insert 方法将项添加到缓存中

调用Insert方法，传递要添加的项的键和值。

下面的代码示例添加名为 CacheItem2 的字符串：

Cache.Insert("CacheItem2", "Cached Item 2");

通过指定依赖项向缓存添加项

调用 Insert 方法，将 CacheDependency 对象的一个实例传递给该方法

1. 下面的代码示例添加名为 CacheItem3 的项，该项依赖于缓存中名为 CacheItem2 的另一个项：

string[] dependencies = { "CacheItem2" };

Cache.Insert("CacheItem3", "Cached Item 3",

new System.Web.Caching.CacheDependency(null, dependencies));

1. 下面的代码示例演示将名为 CacheItem4 的项添加到缓存中，并且在名为 XMLFile.xml 的文件上设置文件依赖项：

Cache.Insert("CacheItem4", "Cached Item 4",

new System.Web.Caching.CacheDependency(

Server.MapPath("XMLFile.xml")));

1. 下面的代码示例演示如何创建多个依赖项。它向缓存中名为 CacheItem1 的另一个项添加键依赖项，向名为 XMLFile.xml 的文件添加文件依赖项。

//创建缓存的文件依赖

System.Web.Caching.CacheDependency dep1 =

new System.Web.Caching.CacheDependency(Server.MapPath("XMLFile.xml"));

string[] keyDependencies2 = { "CacheItem1" };

//创建缓存依赖

System.Web.Caching.CacheDependency dep2 =

new System.Web.Caching.CacheDependency(null, keyDependencies2);

//存放的容器

System.Web.Caching.AggregateCacheDependency aggDep =

new System.Web.Caching.AggregateCacheDependency();

aggDep.Add(dep1);

aggDep.Add(dep2);

//CacheItem5依赖多部分

Cache.Insert("CacheItem5", "Cached Item 5", aggDep);

将设有过期策略的项添加到缓存中

l  调用Insert方法，将绝对过期时间或弹性过期时间传递给该方法。

下面的代码示例将有一分钟绝对过期时间的项添加到缓存中：

Cache.Insert("CacheItem6", "Cached Item 6",null, DateTime.Now.AddMinutes(1d),

System.Web.Caching.Cache.NoSlidingExpiration);

下面的代码示例将有 10 分钟弹性过期时间的项添加到缓存中：

Cache.Insert("CacheItem7", "Cached Item 7",

null, System.Web.Caching.Cache.NoAbsoluteExpiration, new TimeSpan(0, 10, 0));

将设有优先级设置的项添加到缓存中

l调用 Insert 方法，从 CacheItemPriority 枚举中指定一个值。

下面的代码示例将优先级值为 High 的项添加到缓存中：

Cache.Insert("CacheItem8", "Cached Item 8",

null, System.Web.Caching.Cache.NoAbsoluteExpiration,

System.Web.Caching.Cache.NoSlidingExpiration,

System.Web.Caching.CacheItemPriority.High, null);

使用 Add 方法向缓存添加项

下面的代码示例向缓存添加名为 CacheItem9 的项，同时将变量 CachedItem9 的值设置为已添加的项。

string CachedItem9 = (string)Cache.Add("CacheItem9",    "Cached Item 9", null,    System.Web.Caching.Cache.NoAbsoluteExpiration,    System.Web.Caching.Cache.NoSlidingExpiration,    System.Web.Caching.CacheItemPriority.Default,null);

如何：检索缓存项的值

要从缓存中检索数据，应指定存储缓存项的键。不过，由于缓存中所存储的信息为易失信息，即该信息可能由 ASP.NET 移除，因此建议的开发模式是首先确定该项是否在缓存中。如果不在，则应将它重新添加到缓存中，然后检索该项。

检索缓存项的值

通过在 Cache 对象中进行检查来确定该项是否不为 null。如果该项存在，则将它分配给变量。否则，重新创建该项，将它添加到缓存中，然后访问它。

下面的代码示例演示如何从缓存中检索名为 CacheItem 的项。代码将该项的内容分配给名为 cachedString 的变量。如果该项不在缓存中，则代码会将它添加到缓存中，然后将它分配给 cachedString。

string cachedString;

cachedString = (string)Cache["CacheItem"];

if (cachedString == null){ cachedString = "Hello, World.";

Cache.Insert("CacheItem", cachedString);}

如何：从 ASP.NET 缓存中删除项

ASP.NET 缓存中的数据是易失的，即不能永久保存。由于以下任一原因，缓存中的数据可能会自动移除：

缓存已满。

该项已过期。

依赖项发生更改。

从缓存中移除项的具体方法由用于向缓存添加项的代码确定。项从缓存中移除时会向您发出通知。

除了允许从缓存中自动移除项之外，还可以显式移除项。

注意：如果调用 Insert 方法，并向缓存中添加与现有项同名的项，则将从缓存中删除该旧项。

从缓存中显式删除项

l  调用 Remove 方法，以传递要移除的项的键。

下面的示例演示如何移除键为 MyData1 的项。

Cache.Remove("MyData1");

如何：从缓存中移除项时通知应用程序

在大多数缓存方案中，当从缓存中移除项后，直到再次需要此项时，才需要将其放回缓存中。典型的开发模式是在使用项之前始终检查该项是否已在缓存中。如果项位于缓存中，则可以使用。如果不在缓存中，则应再次检索该项，然后将其添加回缓存。

但是，在某些情况下，如果从缓存中移除项时通知应用程序，可能非常有用。例如，您可能具有一个缓存的报告，创建该报告需花费大量的时间进行处理。当该报告从缓存中移除时，您希望重新生成该报告，并立即将其置于缓存中，以便下次请求该报告时，用户不必等待对此报告进行处理。

为了在从缓存中移除项时能够发出通知，ASP.NET 提供了 CacheItemRemovedCallback 委托。该委托定义编写事件处理程序时使用的签名，当对从缓存中移除项进行响应时会调用此事件处理程序。ASP.NET 还提供 CacheItemRemovedReason 枚举，用于指定移除缓存项的原因。

通常，通过在管理尝试检索的特定缓存数据的业务对象中创建处理程序，来实现回调。例如，您可能有一个 ReportManager 对象，该对象具有两种方法，即 GetReport 和 CacheReport。GetReport 报告方法检查缓存以查看报告是否已缓存；如果没有，该方法将重新生成报告并将其缓存。CacheReport 方法具有与 CacheItemRemovedCallback 委托相同的函数签名；从缓存中移除报告时，ASP.NET 会调用 CacheReport 方法，然后将报告重新添加到缓存中。

当从缓存中移除项时通知应用程序

1. 创建一个类，负责从缓存中检索项并处理回调方法，以将项添加回缓存中。
2. 在该类中，创建用于将项添加到缓存中的方法。
3. 在该类中，创建用于从缓存中获取项的方法。
4. 创建用于处理缓存项移除回调的方法。该方法必须具备与 CacheItemRemovedCallback 委托相同的函数签名。从缓存中删除项时，会在该方法中执行要运行的逻辑，如重新生成项并将其添加回缓存中。

测试缓存项回调

1. 创建一个 ASP.NET 网页，该网页将调用类中用于将项添加到缓存中的方法。

下面的代码示例演示如何调用 ReportManager 类的 GetReport 方法（在此过程后面的示例中定义）。然后将在使用页面的Page_Load 方法期间显示 Label 控件 Label1 中的报告。

protected void Page_Load(object sender, EventArgs e)

{

this.Label1.Text = ReportManager.GetReport();

}

1. 在浏览器中请求 ASP.NET 页并查看报告。

报告是在首次请求页时创建的，在缓存中的报告被移除之前，后续请求都将访问缓存中的报告。例子：http://msdn.microsoft.com/zh-cn/library/7kxdx246%28v=vs.80%29.aspx

演练：使用输出缓存增强网站性能

性能是任何 Web 应用程序的关键方面。必须减少 Web 服务器的处理量，以便使单个请求结果响应速度更快、服务器有能力处理更多并发请求并减少中间和后端数据系统的负荷。

使用输出缓存以减少服务器的工作负荷，能够实现更佳的 ASP.NET 性能。输出缓存是一种优化方案，可以缩短 Web 服务器响应的时间。

通常，浏览器请求 ASP.NET 页时，ASP.NET 将创建该页的实例，运行该页中的任何代码，运行数据库查询（如果有），动态汇编此页，然后将产生的输出发送到浏览器。输出缓存使 ASP.NET 能够发送该页的预处理副本，而不用为每个请求完成此过程。这个区别降低了 Web 服务器的处理量，从而提高了性能并获得更大的可伸缩性。

缓存页，使用页指令缓存整个页输出，而不管浏览器类型、各个参数或数据。

使用应用程序级别缓存配置文件，此功能使您能够定义整个应用程序的输出缓存设置。各个页可以与 Web.config 文件中包含的配置文件关联。这使您能够集中控制缓存，而不用编辑每个页。

l根据与页一起发送的各个参数进行缓存。

Sql缓存：http://msdn.microsoft.com/zh-cn/library/ms178604%28v=vs.80%29.aspx

//项目中简单应用

//利用CaChe类建立缓存

/// <summary>获取当前应用程序指定CacheKey的Cache对象值</summary>

/// <param name="CacheKey">索引键值</param>

/// <returns>返回缓存对象</returns>

public static object GetCache(string CacheKey)

{System.Web.Caching.Cache objCache = HttpRuntime.Cache;

return objCache[CacheKey];}

/// <summary>设置当前应用程序指定CacheKey的Cache对象值</summary>

/// <param name="CacheKey">索引键值</param>

/// <param name="objObject">缓存对象</param>

public static void SetCache(string CacheKey, object objObject){

System.Web.Caching.Cache objCache = HttpRuntime.Cache;

objCache.Insert(CacheKey, objObject);}

/// <summary>设置当前应用程序指定CacheKey的Cache对象值</summary>

/// <param name="CacheKey">索引键值</param>

/// <param name="objObject">缓存对象</param>

/// <param name="absoluteExpiration">绝对过期时间</param>

/// <param name="slidingExpiration">最后一次访问所插入对象时与该对象过期时之间的时间间隔</param>

public static void SetCache(string CacheKey, object objObject, DateTime absoluteExpiration, TimeSpan slidingExpiration) {

System.Web.Caching.Cache objCache = HttpRuntime.Cache;

objCache.Insert(CacheKey, objObject, null, absoluteExpiration, slidingExpiration);}

protected void Page_Load(object sender, EventArgs e){

string CacheKey = "cachetest";

object objModel = GetCache(CacheKey);//从缓存中获取

if (objModel == null)//缓存里没有{

objModel = DateTime.Now;//把当前时间进行缓存

if (objModel != null){

;//缓存时间30秒

SetCache(CacheKey, objModel, DateTime.Now.AddSeconds(CacheTime), TimeSpan.Zero);//写入缓存

} } }

//建立缓存依赖项

public static void SetCache(string CacheKey, object objObject, System.Web.Caching.CacheDependency dep){

System.Web.Caching.Cache objCache = HttpRuntime.Cache;

objCache.Insert(CacheKey,objObject, dep,                System.Web.Caching.Cache.NoAbsoluteExpiration,//从不过期

System.Web.Caching.Cache.NoSlidingExpiration,//禁用可调过期

System.Web.Caching.CacheItemPriority.Default, null);  }

protected void Page_Load(object sender, EventArgs e){

string CacheKey = "cachetest";

object objModel = GetCache(CacheKey);//从缓存中获取

if (objModel == null)//缓存里没有 {

objModel = DateTime.Now;//把当前时间进行缓存

if (objModel != null){

//依赖C:\\test.txt 文件的变化来更新缓存

System.Web.Caching.CacheDependency dep = new System.Web.Caching.CacheDependency("C:\\test.txt");

SetCache(CacheKey, objModel, dep);//写入缓存}}}