Explanation:
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:
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.
Programmatic Page Caching
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.
Response.Cache.SetExpires(System.DateTime.Now.AddMinutes(10));
In the same way you can also use Response.Cache.VaryByParams to set the Params programmatically.
Accessing Caching in the Class Libraries
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.
Data Caching
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
}
else {
// 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.
Caching Page Fragments
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
|