What is Caching?
Caching is a technique of storing frequently used data/information in memory, so that, when the same data/information is needed next time, it could be directly retrieved from the memory instead of being generated by the application.
Caching is extremely important for performance boosting in ASP.Net, as the pages and controls are dynamically generated here. It is especially important for data related transactions, as these are expensive in terms of response time.
Caching places frequently used data in quickly accessed media like the random access memory of the computer. The ASP.Net runtime includes a key-value map of CLR objects called cache. This lives with the application and is available via the HttpContext and System.Web.UI.Page.
In some respect, caching is similar to storing the state objects. However, the storing information in state objects is deterministic, i.e., you can count on the data being stored there, and caching of data is nondeterministic.
The data will not be available if its lifetime expires, or the application releases its memory, or caching does not take place for some reason.
You can access items in the cache using an indexer and may control the lifetime of objects in the cache and set up links between the cached objects and their physical sources.
Caching in ASP.Net:
ASP.Net provides the following different types of caching:
Output Caching: Output cache stores a copy of the finally rendered HTML pages or part of pages sent to the client. When the next client requests for this page, instead of regenerating the page, a cached copy of the page is sent, thus saving time.
Data Caching: Data caching means caching data from a data source. As long as the cache is not expired, a request for the data will be fulfilled from the cache. When the cache is expired, fresh data is obtained by the data source and the cache is refilled.
Object Caching: Object caching is caching the objects on a page, such as data-bound controls. The cached data is stored in server memory.
Class Caching: Web pages or web services are compiled into a page class in the assembly, when run for the first time. Then the assembly is cached in the server. Next time when a request is made for the page or service, the cached assembly is referred to. When the source code is changed, the CLR recompiles the assembly.
Configuration Caching: Application wide configuration information is stored in a configuration file. Configuration caching stores the configuration information in the server memory.
Output Caching:
Rendering a page may involve some complex processes like, database access, rendering complex controls etc. Output caching allows bypassing the round trips to server by caching data in memory. Even the whole page could be cached.
The OutputCache directive is responsible of output caching. It enables output caching and provides certain control over its behaviour.
Syntax for OutputCache directive:
<%@ OutputCache Duration="15" VaryByParam="None" %>
|
Put this directive under the page directive . This tells the environment to cache the page for 15 seconds. The following event handler for page load would help in testing that the page was really cached.
protected void Page_Load(object sender, EventArgs e)
{
Thread.Sleep(10000);
Response.Write("This page was generated and cache at:" +
DateTime.Now.ToString());
}
|
The Thread.Sleep() method stops the process thread for the specified time. In this example, the thread is stopped for 10 seconds, so when the page is loaded for first time, it will take 10 seconds. But next time you refresh the page, it does not take any time, as the page will retrieved from the cache without being loaded.
The OutputCache directive has the following attributes, which helps in controlling the behaviour of the output cache:
| Attribute | Values | Description |
|---|
| DiskCacheable | true/false | Specifies that output could be written to a disk based cache. |
| NoStore | true/false | Specifies that the "no store" cache control header is sent or not. |
| CacheProfile | String name | Name of a cache profile as to be stored in web.config. |
| VaryByParam | None
*
Param- name | Semicolon delimited list of string specifies query string values in a GET request or variable in a POST request. |
| VaryByHeader | *
Header names | Semicolon delimited list of strings specifying headers that might be submitted by a client. |
| VaryByCustom | Browser
Custom string | Tells ASP.Net to vary the output cache by browser name and version or by a custom string. |
| Location | Any
Client
Downstream
Server
None | Any: page may be cached anywhere.
Client: cached content remains at browser.
Downstream: cached content stored in downstream and server both.
Server: cached content saved only on server.
None: disables caching. |
| Duration | Number | Number of seconds the page or control is cached. |
Data Caching:
The main aspect of data caching is caching the data source controls. We have already discussed that the data source controls represent data in a data source, like a database or an XML file. These controls derive from the abstract class DataSourceControl and have the following inherited properties for implementing caching:
CacheDuration - sets the number of seconds for which the data source will cache data
CacheExpirationPolicy - defines the cache behaviour when the data in cache has expired
CacheKeyDependency - identifies a key for the controls that auto-expires the content of its cache when removed
EnableCaching - specifies whether or not to cache data
Object Caching:
Object caching provides more flexibility than other cache techniques. You can use object caching to place any object in the cache. The object can be of any type - a data type, a web control, a class, a DataSet object, etc. The item is added to the cache simply by assigning a new key name. Like:
ASP.Net also provides the Insert() method for inserting an object to the cache. This method has four overloaded versions. Let us see the various versions first.
| Overload | Description |
|---|
| Cache.Insert((key, value); | Inserts an item into the cache with the key name and value with default priority and expiration. |
| Cache.Insert(key, value, dependencies); | Inserts an item into the cache with key, value, default priority, expiration and a CacheDependency name that links to other files or items so that when these change the cache item remains no longer valid. |
| Cache.Insert(key, value, dependencies, absoluteExpiration, slidingExpiration); | This indicates an expiration policy along with the above issues. |
| Cache.Insert(key, value, dependencies, absoluteExpiration, slidingExpiration, priority, onRemoveCallback); | This along with the parameters also allows you to set a priority for the cache item and a delegate that, points to a method to be invoked when the item is removed. |
Sliding expiration is used to remove an item from the cache when it is not used for the specified time span. The following code snippet stores an item with a sliding expiration of 10 minutes with no dependencies.
Cache.Insert("my_item", obj, null, DateTime.MaxValue,
TimeSpan.FromMinutes(10));
|
