This class allows you to configure
"page" or output caching for an
ASP.NET application, which stores a fully rendered page for automatic
reuse. A cached page will be used for GET requests until it expires,
as long as the URL request does not have different query string
arguments. A cached page will not be used for POST requests, so
postbacks (such as when a user clicks on button) will bypass the
cached page. (This behavior is slightly and mysteriously different
than just using the <OutputCache> page
directive, which always reuses the cached page for any type of
request when the VaryByParam attribute is set to
None.) To specifically modify this behavior, you
can use the VaryByParams property and the
HttpCacheVaryByParams class.
To enable caching for a page, use the SetCacheability(
) method to set the page's visibility to
Public so it can be stored in the shared cache.
Then use the SetExpires( ) method to determine the
lifetime of the page in the cache. For example,
Response.Cache.SetExpires(DateTime.Now.AddSeconds(60));
will keep a page for 60 seconds, which is enough to make a
substantial performance difference. By default, the cache uses
absolute expiration. You can also invoke the
SetSlidingExpiration( ) method, with the parameter
True, to enable sliding expiration. In sliding
expiration, the time limit is compared to the time elapsed since the
most recent request, not the time since the first request. You can
also use the AddValidationCallback( ) method to
add a callback that decides on a page-by-page basis whether to allow
a cached page to be served. Finally, you can use fragment caching by
developing a Web Form user control for a portion of a page, and
caching just that portion using page directives or the methods of
this class.
If your page requires customization based on Session variables or
user-specific details other than a query string, you
shouldn't cache the page! In these cases, data
caching will be more useful. With data caching, you manually store
specific information, such as binary data or recordsets. For more
information on data caching, refer to the
System.Web.Caching.Cache class.
The HttpCachePolicy class is available through the
Cache property of the built-in
Response object. It replaces properties of the
Response object that were used to configure
caching in ASP (like CacheControl and
Expires). Microsoft uses somewhat confusing
nomenclature. An instance of the HttpCachePolicy
class (used to configure page caching) is available through the
built-in Response.Cache object, and the
System.Web.Caching.Cache class (used for data
caching) is available through the built-in Cache
object. Cache and
Response.Cache are not the same!
public sealed class HttpCachePolicy {
// Public Instance Properties
public HttpCacheVaryByHeaders
VaryByHeaders {get; }
public HttpCacheVaryByParams
VaryByParams {get; }
// Public Instance Methods
public void
AddValidationCallback (HttpCacheValidateHandler
handler , object
data );
public void
AppendCacheExtension (string
extension );
public void
SetAllowResponseInBrowserHistory (bool
allow );
public void
SetCacheability (HttpCacheability
cacheability );
public void
SetCacheability (HttpCacheability
cacheability , string
field );
public void
SetETag (string
etag );
public void
SetETagFromFileDependencies ( );
public void
SetExpires (DateTime
date );
public void
SetLastModified (DateTime
date );
public void
SetLastModifiedFromFileDependencies ( );
public void
SetMaxAge (TimeSpan
delta );
public void
SetNoServerCaching ( );
public void
SetNoStore ( );
public void
SetNoTransforms ( );
public void
SetProxyMaxAge (TimeSpan
delta );
public void
SetRevalidation (HttpCacheRevalidation
revalidation );
public void
SetSlidingExpiration (bool
slide );
public void
SetValidUntilExpires (bool
validUntilExpires );
public void
SetVaryByCustom (string
custom );
}