This tutorial explains about The Importance of Caching, Declarative Page Output Caching, Programmatic Page Caching, Caching Page Fragments, Caching Data and Monitoring Performance.
Caching is one of the coolest features in Asp.net. Caching enables you to store the expensive data into Cache object and later retrieve it without doing expensive operations. A very common example where you want to use caching is datagrid paging. I am sure you all are familiar with datagrid paging which enables you to view the records in multiple pages. Each time you visit a different page all the records are fetched from the database. This becomes very expensive operation. Caching can save a lot of expensive operations since you can store all the records in the cache object and use the cache object as the data source. In this article we will see some important features that caching provides.
Output caching is used for pages and is also known as Page-level caching. All you need to do to enable output caching is to add a directive in your html view of the aspx page. The output directive can be written like this:
@ OutputCache Duration="60" VaryByParam="none"
The page will be cached for 60 seconds the VaryByParam attribute is set to "none" which means that there is no sort of caching implemented. Hence if the first user requested page which contains item1 than the second user will also see item1 even if he is requesting item2.
That's why we always specify what the caching depends on.
@ OutputCache Duration="60" VaryByParam="Category"
In the above OutputCache directive you can notice that I changed the VaryByParam attribute to "Category" which means that now the result of caching depends upon Category. Here Category represents the name of the column in the database.
You can also use caching programmatically, meaning that you can change the value of cache depending upon the tasks performed by the user. The Response.Cache class let's you access the functionality to work with the cache object.
You can change the expiration time on the Cache using the SetExpires method of the Response.Cache class.
In the same way you can also use Response.Cache.VaryByParams to set the Params programmatically.
Sometimes you will need to access the caching object in the class library. You cannot use Response class anymore since its only limited to the asp.net code behind page. For accessing cache in class library you will have to use HttpContext.Current.Cache. Also don't forget to include System.web namespace.
Caching is one of the coolest features in Asp.net. Caching enables you to store the expensive data into Cache object and later retrieve it without doing expensive operations. Data Caching can tremendously increase performance since each time the data is requested you can turn to the Cache object rather than going to the database and fetching the result.
You all must be familiar with datagrid paging where you can display certain number of records in the datagrid control and use the numeric or next-previous buttons to view the other records. All the records are fetched for each and every page in the datagrid. Meaning that if you have 40000 records in the database and you are using paging. Each time you click to go to the next page you retrieve 40000 records. This is way too much performance kill. That's why for this task we can use Data Caching, let's see how we can use data caching to make our application more efficient.
private void Button3_Click(object sender, System.EventArgs e)
if(Cache["MyArticles"] == null)
// Go to the database and fetch the result in the DataSet
// Assign the dataset to the Cache object
// Cache["MyArticles"] = ds
// This means that Cache is not empty and there is data in the cache
// Extract the value of Cache object to the DataSet
// DataSet ds = (DataSet) Cache["MyArticles"]
The above example is pretty much simple and as you have also noticed that the syntax for using Data Caching is very similar to the ViewState object. By using this technique you will only get the data from the database if the Cache is empty. And if you see the page source you will not find any hidden fields since Cache is stored in memory rather than in page source.
Fragment Caching refers to caching the sections of the page. These sections are most commonly UserControls. Page fragment caching allows you to cache the small portion of the page instead of caching the whole page.
Let's see some examples of fragment caching and how it can be used.
@ OutputCache Duration="120" VaryByParam="CategoryID;SelectedID"
In the Page directive above we have cached CategoryID and SelectedID for 120 seconds. Both of these are the query string parameters.
This means that if the first user request CategoryID = 2 and the second user request the same CategoryID than the second user will recieve the contents from the cache object instead of going to the database and pulling records.
@ OutputCache Duration="120" VaryByParam="none" VaryByControl="Category"
The VaryByControl attribute can only be used in fragment caching. You can use this to cache the value of the controls. These controls can be any server controls like dropdownlist or datagrid.
When using fragment caching you only need to put the cache directive in the user control and not on the page.
You can use different type of tools to monitor your performance before and after caching is used. Some of the good tools are NProf and ACT