This article was written by Shiju Varghese for the DNC Magazine.
Today, scalability and performance are the most challenging areas in web application development. Performance optimizations are very critical for web apps when apps are being accessed by several ten thousands of users concurrently. Caching solutions can have a key role for building high performance web apps which can avoid lot of round trips to backend sources thus giving you better performance and better scalability.
This article is published from the September Edition of the DNC Magazine – A Free High Quality Digital Magazine for .NET professionals published once every two months.
The September edition featured hot topics like Windows 8 Apps in all shape, form and size - WinRT+C#+XAML, WinRT+WinJS, WinRT+Testing and even a Tiled Web Framework! Apart from that we had WCF 4.5, Testing Benefits, Azure Caching and Hadoop On Azure too! Last but not least, our special guest in the Interview chair. The one and only Jon Skeet!.
Click Here to Download all the issues of this Free .NET Magazine
This article will give an introduction to the new Windows Azure Caching introduced in the Windows Azure SDK 1.7 and will demonstrate how to use Windows Azure Caching for your Windows Azure apps for building high performance cloud applications. This article will demonstrate the following:
- Introduction to Windows Azure Caching
- Introduce the different type of deployment options available for Cache and how to configure Cache Cluster
- How to build Cache Clients for accessing Windows Azure Caching
- Working with the Windows Azure Caching
- How to use Windows Azure Caching as the storage mechanism for ASP.NET session state and ASP.NET Page Output Caching
Windows Azure Caching
Windows Azure is providing a caching service which can be used as a caching layer for your Cloud apps hosted on Windows Azure. Windows Azure Caching service is a highly scalable, distributed, in-memory Cache which allows developers to cache all data types, thus reducing the load on databases and improving the performance of the Windows Azure applications.
Using Windows Azure Caching, you can do the following:
- Cache data on Windows Azure Caching
- Use as storage mechanism for ASP.NET session state and ASP.NET page output caching
The new Windows Azure Caching allows you to deploy Cache on the virtual machines in which you have hosted your Windows Azure Cloud Services. Now you can cache on Web Roles and Worker Roles that can be easily scaled, managed and monitored just like your Cloud Services. You can also use the existing Windows Azure Shared Caching along with the new Caching option on the Cloud Services.
Cache Cluster is the Cloud Service role instance that you use for hosting your Cache. You can deploy the cache cluster in two different ways. You can deploy in a dedicated VM as well as you can share Caching with your Role instances.
The following are the two types of deployment options available for configuring cache.
· Co-located Role caching - The Cache shares the Virtual Machine resources with the Cloud Service application. In this option, you can share the resources of Web Role and Worker Role for Cache.
· Dedicated Role caching - The role instances dedicated only for your caching. In this way, you would be deploy the Cache in a dedicated VM by using a Cache Worker Role.
Configuring Co-located Role Cache Cluster
If you want to configure your cache along with your Role instances, you can choose the co-located Role cache cluster as the deployment option.
The following steps will configure the Windows Azure Role for using co-located Role Caching
1. In Visual-Studio, right-click on the Windows Azure Role, and click properties.
2. In the properties window, choose the 'Caching' tab.
3. In the Caching tab, check the 'Enable Caching (Preview Release)' checkbox.
4. Choose 'Co-located Role' for the Cache Cluster settings. By default, this will be 'Co-located Role' when we enable Caching.
5. Choose the percentage of Cache size. By default Cache size will be 30 percentage. This means that 30 percentage of VM memory allocated for Cache. You can change the Cache size whatever you want for your caching solution.
6. Configure the settings of Caches. We can specify the 'Time to Live (min)' for the time interval of Cache for expiry and 'Expiration Type' for specifying the expiration type of Cache object.
By default, value of “The Time to Live” would be 10 minutes and the Expiration Type would be Absolute. The Absolute expiration type is specifying that the timer for the expiration would be start after the data added into Cache object. If the expiration time is 10 minutes, the cache will be expire after 10 minutes when the item is added into Cache. The other expiration types are 'Sliding Window' and 'None'. If the Expiration Type is 'Sliding Window', the timer for the expiration time would be reset after each item is retrieved from the Cache. If expiration type is 'None', items in the cache will not be expired. In this scenario, you have to specify “Time to Live (min)” as 0.
Configuring Dedicated Role Cache Cluster
If you want to host your cache in a dedicated VM, you can choose the Dedicated Role cache cluster as the deployment option.
The following steps will configure the Dedicated Role cache cluster
1. Add Cache Worker Role project - To configure Dedicated Role cache cluster, you need to add a Cache Worker Role to your solution. Add a New Cache Worker Role project onto
your Windows Azure project.
When we are adding a new Cache Worker Role project, it will automatically enable Caching with Dedicated Role as the Cache cluster.
2. Configure the settings for Dedicated Cache Role - Right-click on the Cache Worker Role from the Windows Azure project, and click properties and choose Configuration
By default, the VM instance count would be 1 and Virtual Machine size would be small. You can change these setting based on your hosting plan for Dedicated Role Cache Cluster.
3. Configure the Cache settings for expiration time and expiration type.
Working with Cache Clients
In order to work with Windows Azure caching from Cloud Services applications, we need to install Windows Azure Caching client library onto your Web Role and Worker Role applications. The following steps will add a Windows Azure client library to a Web Role application. We can install the Windows Azure Caching client library by using NuGet.
From the following NuGet packages, Install Microsoft.WindowsAzure.Caching
The Windows Azure Caching NuGet package will install the necessary assmebly reference and will also add the configuartion setting on the configuaration file. You can also manually add the necessary assmeblies from the folder C:\Program Files\Microsoft SDKs\Windows Azure\.NET SDK\2012-06\ref\CachingPreview if you have installed Windows Azure SDK 1.7 on your system. At the time of this writing, Azure SDK 1.8 is the latest.
The Windows Azure Caching NuGet package will add a configuration element dataCacheClients into the web.config file.
The following configuration setting in the web.config file will configured a cache client for a web role application.
The identifier in the config settings specifies the name of the role that hosts the cache cluster
Programming with Windows Azure Caching
In order to work with Windows Azure Caching from client apps, you need to add the following namespace in your client app:
To programmatically access the Windows Azure Caching, you first need to create an instance of DataCache class.
The following code block will create a cache client by creating an instance of DataCache which will take the settings from configuration file.
//Creating a cache object
DataCacheFactory cacheFactory = new DataCacheFactory();
DataCache dataCache = cacheFactory.GetDefaultCache();
The above code block will create the cache client object by using DataCacheFactory object. The GetDefaultCache method of DataCacheFactory object will return the DataCache object.
Adding and Retrieving Data from the Windows Azure Cache
To add an item to Cache object, we can use either Add or Put method of DataCache object. The Add method adds an object to the Cache object with a specified key and will generate an exception if the item is already exists with the same key. The put method adds the object to the Cache object with a specified key if the key does not exist, and replaces if the key is already exists.
The following code block adds the collection of data objects to Cache:
//Query from DB and adding data to Cache
var categories = categoryRepository.GetAll();
In the above code block, querying data from Database and adding this data to Cache object with a key name “categories” and we can take the data from Cache for the subsequent requests for the same data which can avoid database round trips and improve the performance of the application.
Using the overloads of the Add and Put methods of DataCache object, we can override the timeout interval, which are specified in the Cache Roles settings.
The following code block adds the data to the Cache with time span that allows to specify when the object should expired from Cache.
dataCache.Add("categories", categories, TimeSpan.FromMinutes(45));
The above code block adds the data to the Cache object with a key categories and specified the timeout as 45 minutes.
The following code block retrieves the data from Cache:
//Getting the Cache item with key "categories"
IEnumerable category = dataCache.Get("categories") as IEnumerable;
The Get method of the DataCache object retrieves the data from Cache where you have to give the key as the parameter value for the Get method. The above code block retrieves the data and casting it for the appropriate data type.
Working with a Cache Provider Class
In the previous steps, we have discussed how to perform data caching with Windows Azure Caching. Let’s create a Cache provider class that will help us better manage Data in the cache. Let’s create a contract type for the Cache provider.
public interface ICacheProvider
object Get(string key);
void Add(string key, object data);
void Put(string key, object data);
void Add(string key, object data, TimeSpan? timeout);
void Put(string key, object data, TimeSpan? timeout);
bool IsSet(string key);
void Remove(string key);
The Get method returns the cached item based on the given key and Add and Put methods adds and puts an item into Cache. The IsSet method will return true if an item added on the Cache. The Remove method will remove an item from the Cache.
Let’s create a concrete implementation for the ICacheProvider. The below AzureCacheProvider Class is an implementation of ICacheProvider for Windows Azure Caching.
public class AzureCacheProvider : ICacheProvider
private DataCache dataCache=null;
//Creating a cache object by using DataCacheFactory
DataCacheFactory cacheFactory = new DataCacheFactory();
dataCache = cacheFactory.GetDefaultCache();
//Get cached item
public object Get(string key)
public void Add(string key, object data)
Add(key, data, null);
public void Add(string key, object data, TimeSpan? timeout)
//Add item to Cache
dataCache.Add(key, data, timeout.Value);
public void Put(string key, object data)
Put(key, data, null);
public void Put(string key, object data, TimeSpan? timeout)
//Put item to Cache
dataCache.Put(key, data, timeout.Value);
//Returns true if Cache item is exist
public bool IsSet(string key)
return (dataCache.Get(key) != null);
public void Remove(string key)
In the below code block, we are using the ICacheProvider from an ASP.NET MVC application
private readonly ICacheProvider cache;
public CategoryController(ICategoryRepository categoryRepository,ICacheProvider cache)
this.categoryRepository = categoryRepository;
this.cache = cache;
public ActionResult Index()
if (cachedCategories != null)
categories = cachedCategories as IEnumerable;
categories = categoryRepository.GetAll();
In the Index action method, we are taking the data from Cache, if the cached item exists. If the item does not exist, we retrieve the data from Database and put it on Cache so that we can take the data from Cache for the subsequent requests. In this sample code, we are injecting an instance of AzureCacheProvider class through constructor for the contract type ICacheProvider.
Using Windows Azure Caching for ASP.NET Session State and ASP.NET Page Output Caching
In addition to the data caching, we can also use Windows Azure Caching as the storage mechanism for ASP.NET Session State and ASP.NET Page Output Caching. The Session State Provider for Windows Azure Caching and the Output Cache Provider for Windows Azure Caching are the out-of-process storage for ASP.NET applications which will greatly work with Windows Azure load balancers. To use Windows Azure Caching as the storage mechanism for ASP.NET Session State and ASP.NET Page Output Caching, first you need to configure Cache Cluster (using one of the two approaches explained above) and then you need to configure your ASP.NET application to use the Windows Azure Caching. After you have configured the Cache Cluster, you can use Windows Azure Caching for ASP.NET Session State and ASP.NET Page Output Caching by adding necessary configuration setting in the web.config file.
The following configuration setting in the web.config allows to use the Session State Provider for Windows Azure Caching for web applications.
The cacheName specifies the name of the Cache used for persisting Session State data.
The following configuration setting in the web.config configures the Session State Provider for Windows Azure Caching for web applications
The Windows Azure Caching introduced in the Windows Azure SDK 1.7 is a high performance distributed, in-memory caching solution. Using Windows Azure Caching, you can host your Cache in the Virtual Machine of your Web Role and Worker Role. You can deploy the Cache in a Co-located Role which allows you use some portions of the VMs memory as Cache. You can also deploy to Dedicated Role where you can use a VM specifically dedicated for Caching. Windows Azure Caching comes with ASP.NET providers for Session state and Page Output Caching and can thus be used as storage mechanism for these. Thus Windows Azure Caching enables you to build high performance cloud apps on the Windows Azure platform.
Download the entire source code of this article (Github)