ASP.NET applications can make use of
the System.Web.Caching.Cache object to cache data and prevent repeated expensive calls to a database or other store. However, ideally an application should make use of caching at
the point where data is retrieved from
the database, which typically is inside a Business Objects or Model layer. One of
the key features of using a UI pattern such as Model-View-Presenter (MVP) or Model-View-Controller (MVC) is that
the Model and Presenter (or Controller) layers are developed without any knowledge of
the UI layer. Introducing a dependency on System.Web into
the Model layer would break this independence of
the Model from
the View.
This article gives a solution to this problem, using dependency injection to inject
the caching implementation into
the Model layer at runtime. This allows caching to be used within
the Model layer, without any knowledge of
the actual caching mechanism that will be used.
Create a sample application to use
the caching solution
Create a test SQL Server database
This solution uses a SQL Server database with
the same Sales data used in my previous post on calculating running totals.
The advantage of using this data is that it gives nice slow queries that will exaggerate
the effect of using caching!
To create
the data, first create a new SQL database called CacheSample. Next run
the following script to create
the Sale table and populate it:
USE CacheSample
GO
CREATE TABLE Sale(DayCount smallint, Sales money)
CREATE CLUSTERED INDEX ndx_DayCount ON Sale(DayCount)
go
INSERT Sale VALUES (1,120)
INSERT Sale VALUES (2,60)
INSERT Sale VALUES (3,125)
INSERT Sale VALUES (4,40)
DECLARE @DayCount smallint, @Sales money
SET @DayCount = 5
SET @Sales = 10
WHILE @DayCount < 5000
BEGIN
INSERT Sale VALUES (@DayCount,@Sales)
SET @DayCount = @DayCount + 1
SET @Sales = @Sales + 15
END
Next create a stored procedure to calculate
the running total, and return a specified number of rows from
the Sale table, using
the following script:
USE [CacheSample]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author: Robin
-- Create date:
-- Description:
-- =============================================
CREATE PROCEDURE [dbo].[spGetRunningTotals]
-- Add
the parameters for
the stored procedure here
@HighestDayCount smallint = null
AS
BEGIN
-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON;
IF @HighestDayCount IS NULL
SELECT @HighestDayCount = MAX(DayCount) FROM dbo.Sale
DECLARE @SaleTbl TABLE (DayCount smallint, Sales money, RunningTotal money)
DECLARE @DayCount smallint,
@Sales money,
@RunningTotal money
SET @RunningTotal = 0
SET @DayCount = 0
DECLARE rt_cursor CURSOR
FOR
SELECT DayCount, Sales
FROM Sale
ORDER BY DayCount
OPEN rt_cursor
FETCH NEXT FROM rt_cursor INTO @DayCount,@Sales
WHILE @@FETCH_STATUS = 0 AND @DayCount <= @HighestDayCount
BEGIN
SET @RunningTotal = @RunningTotal + @Sales
INSERT @SaleTbl VALUES (@DayCount,@Sales,@RunningTotal)
FETCH NEXT FROM rt_cursor INTO @DayCount,@Sales
END
CLOSE rt_cursor
DEALLOCATE rt_cursor
SELECT DayCount, Sales, RunningTotal
FROM @SaleTbl
END
GO
Create
the Sample ASP.NET application
In Visual Studio create a new solution and add a class library project called CacheSample.BusinessObjects and an ASP.NET web application called CacheSample.UI.
The CacheSample.BusinessObjects project will contain a single class to represent a Sale data item, with all
the code to retrieve
the sales from
the database included in it for simplicity (normally I would at least have a separate Repository or other object that is responsible for retrieving data, and probably a data access layer as well, but for this sample I want to keep it simple).
The C# code for
the Sale class is shown below:
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
namespace CacheSample.BusinessObjects
{
public class Sale
{
public Int16 DayCount { get; set; }
public decimal Sales { get; set; }
public decimal RunningTotal { get; set; }
public static IEnumerable<Sale> GetSales(int? highestDayCount)
{
List<Sale> sales = new List<Sale>();
SqlParameter highestDayCountParameter = new
SqlParameter("@HighestDayCount", SqlDbType.SmallInt);
if (highestDayCount.HasValue)
highestDayCountParameter.Value = highestDayCount;
else
highestDayCountParameter.Value = DBNull.Value;
string connectionStr =
System.Configuration.ConfigurationManager
.ConnectionStrings["CacheSample"].ConnectionString;
using(SqlConnection sqlConn = new SqlConnection(connectionStr))
using (SqlCommand sqlCmd = sqlConn.CreateCommand())
{
sqlCmd.CommandText = "spGetRunningTotals";
sqlCmd.CommandType = CommandType.StoredProcedure;
sqlCmd.Parameters.Add(highestDayCountParameter);
sqlConn.Open();
using (SqlDataReader dr = sqlCmd.ExecuteReader())
{
while (dr.Read())
{
Sale newSale = new Sale();
newSale.DayCount = dr.GetInt16(0);
newSale.Sales = dr.GetDecimal(1);
newSale.RunningTotal = dr.GetDecimal(2);
sales.Add(newSale);
}
}
}
return sales;
}
}
}
The static GetSale() method makes a call to
the spGetRunningTotals stored procedure and then reads each row from
the returned SqlDataReader into an instance of
the Sale class, it then returns a List of
the Sale objects, as IEnnumerable<Sale>. A reference to System.Configuration needs to be added to
the CacheSample.BusinessObjects project so that
the connection string can be read from
the web.config file.
In
the CacheSample.UI ASP.NET project, create a single web page called ShowSales.aspx, and make this
the default start up page. This page will contain a single button to call
the GetSales() method and a label to display
the results.
The html mark up and
the C# code behind are shown below:
ShowSales.aspx
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="ShowSales.aspx.cs" Inherits="CacheSample.UI.ShowSales" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Cache Sample - Show All Sales</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Button ID="btnTest1" runat="server" onclick="btnTest1_Click"
Text="Get All Sales" />
<asp:Label ID="lblResults" runat="server"></asp:Label>
</div>
</form>
</body>
</html>
ShowSales.aspx.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using CacheSample.BusinessObjects;
namespace CacheSample.UI
{
public partial class ShowSales : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
protected void btnTest1_Click(object sender, EventArgs e)
{
System.Diagnostics.Stopwatch stopWatch =
new System.Diagnostics.Stopwatch();
stopWatch.Start();
var sales = Sale.GetSales(null);
var lastSales = sales.Last();
stopWatch.Stop();
lblResults.Text = string.Format(
"Count of Sales: {0}, Last DayCount: {1}, Total Sales: {2}. Query took {3} ms",
sales.Count(),
lastSales.DayCount,
lastSales.RunningTotal,
stopWatch.ElapsedMilliseconds);
}
}
}
Finally we need to add a connection string to
the CacheSample SQL Server database, called CacheSample, to
the web.config file:
<?xmlversion="1.0"?>
<configuration>
<connectionStrings>
<addname="CacheSample"
connectionString="data source=.\SQLEXPRESS;Integrated Security=SSPI;Initial Catalog=CacheSample"
providerName="System.Data.SqlClient" />
</connectionStrings>
<system.web>
<compilationdebug="true"targetFramework="4.0" />
</system.web>
</configuration>
Run
the application and click
the button a few times to see how long each call to
the database takes. On my system, each query takes about 450ms.
Next I shall look at a solution to use
the ASP.NET caching to cache
the data returned by
the query, so that subsequent requests to
the GetSales() method are much faster.
Adding Data Caching Support
I am going to create my caching support in a separate project called CacheSample.Caching, so
the next step is to add a class library to
the solution. We shall be using
the application configuration to define
the implementation of our caching system, so we need a reference to System.Configuration adding to
the project.
ICacheProvider<T> Interface
The first step in adding caching to our application is to define an interface, called ICacheProvider, in
the CacheSample.Caching project, with methods to retrieve any data from
the cache or to retrieve
the data from
the data source if it is not present in
the cache. Dependency Injection will then be used to inject an implementation of this interface at runtime, allowing
the users of
the interface (i.e.
the CacheSample.BusinessObjects project) to be completely unaware of how
the caching is actually implemented. As data of any type maybe retrieved from
the data source, it makes sense to use generics in
the interface, with a generic type parameter defining
the data type associated with a particular instance of
the cache interface implementation.
The C# code for
the ICacheProvider interface is shown below:
using System;
using System.Collections.Generic;
namespace CacheSample.Caching
{
public interface ICacheProvider
{
}
public interface ICacheProvider<T> : ICacheProvider
{
T Fetch(string key,
Func<T> retrieveData,
DateTime? absoluteExpiry,
TimeSpan? relativeExpiry);
IEnumerable<T> Fetch(string key,
Func<IEnumerable<T>> retrieveData,
DateTime? absoluteExpiry,
TimeSpan? relativeExpiry);
}
}
The empty non-generic interface will be used as a type in a Dictionary generic collection later to store instances of
the ICacheProvider<T> implementation for reuse, I prefer to use a base interface when doing this, as I think
the alternative of using object makes for less clear code.
The ICacheProvider<T> interface defines two overloaded Fetch methods,
the difference between these is that one will return a single instance of
the type T and
the other will return an IEnumerable<T>, providing support for easy caching of collections of data items.
Both methods will take a key parameter, which will uniquely identify
the cached data, a delegate of type Func<T> or Func<IEnumerable<T>> which will provide
the code to retrieve
the data from
the store if it is not present in
the cache, and absolute or relative expiry policies to define when a cached item should expire. Note that at present there is no support for cache dependencies, but I shall be showing a method of adding this in part two of this article.
CacheProviderFactory Class
We need a mechanism of creating instances of our ICacheProvider<T> interface, using Dependency Injection to get
the implementation of
the interface. To do this we shall create a CacheProviderFactory static class in
the CacheSample.Caching project. This factory will provide a generic static method called GetCacheProvider<T>(), which shall return instances of ICacheProvider<T>. We can then call this factory method with
the relevant data type (for example
the Sale class in
the CacheSample.BusinessObject project) to get a instance of ICacheProvider for that type (e.g. call CacheProviderFactory.GetCacheProvider<Sale>() to get
the ICacheProvider<Sale> implementation).
The C# code for
the CacheProviderFactory is shown below:
using System;
using System.Collections.Generic;
using CacheSample.Caching.Configuration;
namespace CacheSample.Caching
{
public static class CacheProviderFactory
{
private static Dictionary<Type, ICacheProvider> cacheProviders
= new Dictionary<Type, ICacheProvider>();
private static object syncRoot = new object();
///<summary>
/// Factory method to create or retrieve an implementation of
the
/// ICacheProvider interface for type <typeparamref name="T"/>.
///</summary>
///<typeparam name="T">
///
The type that this cache provider instance will work with
///</typeparam>
///<returns>An instance of
the implementation of ICacheProvider for type
///<typeparamref name="T"/>, as specified by
the application
/// configuration</returns>
public static ICacheProvider<T> GetCacheProvider<T>()
{
ICacheProvider<T> cacheProvider = null;
// Get
the Type reference for
the type parameter T
Type typeOfT = typeof(T);
// Lock
the access to
the cacheProviders dictionary
// so multiple threads can work with it
lock (syncRoot)
{
// First check if an instance of
the ICacheProvider implementation
// already exists in
the cacheProviders dictionary for
the type T
if (cacheProviders.ContainsKey(typeOfT))
cacheProvider = (ICacheProvider<T>)cacheProviders[typeOfT];
else
{
// There is not already an instance of
the ICacheProvider in
// cacheProviders for
the type T
// so we need to create one
// Get
the Type reference for
the application's implementation of
// ICacheProvider from
the configuration
Type cacheProviderType =
Type.GetType(CacheProviderConfigurationSection.Current.
CacheProviderType);
if (cacheProviderType != null)
{
// Now get a Type reference for
the Cache Provider with
the
// type T generic parameter
Type typeOfCacheProviderTypeForT =
cacheProviderType.MakeGenericType(new Type[] { typeOfT });
if (typeOfCacheProviderTypeForT != null)
{
// Create
the instance of
the Cache Provider and add it to
//
the cacheProviders dictionary for future use
cacheProvider =
(ICacheProvider<T>)Activator.
CreateInstance(typeOfCacheProviderTypeForT);
cacheProviders.Add(typeOfT, cacheProvider);
}
}
}
}
return cacheProvider;
}
}
}
As this code uses Activator.CreateInstance() to create instances of
the ICacheProvider<T> implementation, which is a slow process,
the factory class maintains a Dictionary of
the previously created instances so that a cache provider needs to be created only once for each type.
The type of
the implementation of ICacheProvider<T> is read from a custom configuration section in
the application configuration file, via
the CacheProviderConfigurationSection class, which is described below.
CacheProviderConfigurationSection Class
The implementation of ICacheProvider<T> will be specified in a custom configuration section in
the application’s configuration. To handle this create a folder in
the CacheSample.Caching project called Configuration, and add a class called CacheProviderConfigurationSection to this folder. This class will extend
the System.Configuration.ConfigurationSection class, and will contain a single string property called CacheProviderType.
The C# code for this class is shown below:
using System;
using System.Configuration;
namespace CacheSample.Caching.Configuration
{
internal class CacheProviderConfigurationSection : ConfigurationSection
{
public static CacheProviderConfigurationSection Current
{
get
{
return (CacheProviderConfigurationSection)
ConfigurationManager.GetSection("cacheProvider");
}
}
[ConfigurationProperty("type", IsRequired=true)]
public string CacheProviderType
{
get
{
return (string)this["type"];
}
}
}
}
Adding Data Caching to
the Sales Class
We now have enough code in place to add caching to
the GetSales() method in
the CacheSample.BusinessObjects.Sale class, even though we do not yet have an implementation of
the ICacheProvider<T> interface.
We need to add a reference to
the CacheSample.Caching project to CacheSample.BusinessObjects so that we can use
the ICacheProvider<T> interface within
the GetSales() method.
Once
the reference is added, we can first create a unique string key based on
the method name and
the parameter value, so that
the same cache key is used for repeated calls to
the method with
the same parameter values. Then we get an instance of
the cache provider for
the Sales type, using
the CacheProviderFactory, and pass
the existing code to retrieve
the data from
the database as
the retrievalMethod delegate in a call to
the Cache Provider Fetch() method.
The C# code for
the modified GetSales() method is shown below:
public static IEnumerable<Sale> GetSales(int? highestDayCount)
{
string cacheKey =
string.Format("CacheSample.BusinessObjects.GetSalesWithCache({0})",
highestDayCount);
return CacheSample.Caching.CacheProviderFactory.
GetCacheProvider<Sale>().Fetch(cacheKey,
delegate()
{
List<Sale> sales = new List<Sale>();
SqlParameter highestDayCountParameter = new
SqlParameter("@HighestDayCount", SqlDbType.SmallInt);
if (highestDayCount.HasValue)
highestDayCountParameter.Value = highestDayCount;
else
highestDayCountParameter.Value = DBNull.Value;
string connectionStr =
System.Configuration.ConfigurationManager.
ConnectionStrings["CacheSample"].ConnectionString;
using (SqlConnection sqlConn = new SqlConnection(connectionStr))
using (SqlCommand sqlCmd = sqlConn.CreateCommand())
{
sqlCmd.CommandText = "spGetRunningTotals";
sqlCmd.CommandType = CommandType.StoredProcedure;
sqlCmd.Parameters.Add(highestDayCountParameter);
sqlConn.Open();
using (SqlDataReader dr = sqlCmd.ExecuteReader())
{
while (dr.Read())
{
Sale newSale = new Sale();
newSale.DayCount = dr.GetInt16(0);
newSale.Sales = dr.GetDecimal(1);
newSale.RunningTotal = dr.GetDecimal(2);
sales.Add(newSale);
}
}
}
return sales;
},
null,
new TimeSpan(0, 10, 0));
}
This example passes
the code to retrieve
the Sales data from
the database to
the Cache Provider as an
anonymous method, however it could also be written as a lambda.
The main advantage of using an
anonymous function (method or lambda) is that
the code inside
the anonymous function can access
the parameters passed to
the GetSales() method. Finally
the absolute expiry is set to null, and
the relative expiry set to 10 minutes, to indicate that
the cache entry should be removed 10 minutes after
the last request for
the data.
As
the ICacheProvider<T> has a Fetch() method that returns IEnumerable<T>, we can simply return
the results of
the Fetch() method to
the caller of
the GetSales() method.
This should be all that is needed for
the GetSales() method to now retrieve data from a cache after
the first time
the data has be retrieved from
the database.
Implementing a ASP.NET Cache Provider
The final step is to actually implement
the ICacheProvider<T> interface, and add
the implementation details to
the web.config file for
the dependency injection.
The cache provider implementation needs to have access to System.Web. Therefore it could be placed in
the CacheSample.UI project, or in its own project that has a reference to System.Web. Implementing
the Cache Provider in a separate project is my favoured approach.
Create a new project inside
the solution called CacheSample.CacheProvider, and add references to System.Web and CacheSample.Caching to this project. Add a class to
the project called AspNetCacheProvider. Make
the class a generic class by adding
the generic parameter <T> and indicate that
the class implements ICacheProvider<T>.
The C# code for
the AspNetCacheProvider class is shown below:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Caching;
using CacheSample.Caching;
namespace CacheSample.CacheProvider
{
public class AspNetCacheProvider<T> : ICacheProvider<T>
{
#region ICacheProvider<T> Members
public T Fetch(string key, Func<T> retrieveData,
DateTime? absoluteExpiry, TimeSpan? relativeExpiry)
{
return FetchAndCache<T>(key, retrieveData,
absoluteExpiry, relativeExpiry);
}
public IEnumerable<T> Fetch(string key, Func<IEnumerable<T>> retrieveData,
DateTime? absoluteExpiry, TimeSpan? relativeExpiry)
{
return FetchAndCache<IEnumerable<T>>(key, retrieveData,
absoluteExpiry, relativeExpiry);
}
#endregion
#region Helper Methods
private U FetchAndCache<U>(string key, Func<U> retrieveData,
DateTime? absoluteExpiry, TimeSpan? relativeExpiry)
{
U value;
if (!TryGetValue<U>(key, out value))
{
value = retrieveData();
if (!absoluteExpiry.HasValue)
absoluteExpiry = Cache.NoAbsoluteExpiration;
if (!relativeExpiry.HasValue)
relativeExpiry = Cache.NoSlidingExpiration;
HttpContext.Current.Cache.Insert(key, value,
null, absoluteExpiry.Value, relativeExpiry.Value);
}
return value;
}
private bool TryGetValue<U>(string key, out U value)
{
object cachedValue = HttpContext.Current.Cache.Get(key);
if (cachedValue == null)
{
value = default(U);
return false;
}
else
{
try
{
value = (U)cachedValue;
return true;
}
catch
{
value = default(U);
return false;
}
}
}
#endregion
}
}
The two interface Fetch() methods call a private method called FetchAndCache(). This method first checks for a element in
the HttpContext.Current.Cache with
the specified cache key, and if so tries to cast this to
the specified type (either T or IEnumerable<T>). If
the cached element is found,
the FetchAndCache() method simply returns it. If it is not found in
the cache,
the method calls
the retrievalMethod delegate to get
the data from
the data source, and then adds this to
the HttpContext.Current.Cache.
The final step is to add
the AspNetCacheProvider class to
the relevant custom configuration section in
the CacheSample.UI.Web.Config file. To do this there needs to be a <configSections> element added as
the first element in <configuration>. This will match a custom section called <cacheProvider> with
the CacheProviderConfigurationSection. Then we add a <cacheProvider> element, with a type property set to
the fully qualified assembly name of
the AspNetCacheProvider class, as shown below:
<?xmlversion="1.0"?>
<configuration>
<configSections>
<sectionname="cacheProvider"
type="CacheSample.Base.Configuration.CacheProviderConfigurationSection, CacheSample.Base" />
</configSections>
<connectionStrings>
<addname="CacheSample"
connectionString="data source=.\SQLEXPRESS;Integrated Security=SSPI;Initial Catalog=CacheSample"
providerName="System.Data.SqlClient" />
</connectionStrings>
<cacheProvidertype="CacheSample.CacheProvider.AspNetCacheProvider`1, CacheSample.CacheProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">
</cacheProvider>
<system.web>
<compilationdebug="true"targetFramework="4.0" />
</system.web>
</configuration>
One point to note is that
the fully qualified assembly name of
the AspNetCacheProvider class includes
the notation `1 after
the class name, which indicates that it is a generic class with a single generic type parameter.
The CacheSample.UI project needs to have references added to CacheSample.Caching and CacheSample.CacheProvider so that
the actual application is aware of
the relevant cache provider implementation.
Conclusion
After implementing this solution, you should have a working cache provider mechanism, that will allow
the middle and data access layers to implement caching support when retrieving data, without any knowledge of
the actually caching implementation. If
the UI is not ASP.NET based, if for example it is Winforms or WPF,
the implementation of ICacheProvider<T> would be written around whatever technology is available. It could even be a standalone caching system that takes full responsibility for adding and removing items from a global store.
The next part of this article will show how this caching mechanism may be extended to provide support for cache dependencies, such as
the System.Web.Caching.SqlCacheDependency.
Another possible extension would be to cache
the cache provider implementations instead of storing them in a static Dictionary in
the CacheProviderFactory. This would prevent a build up of seldom used cache providers in
the application memory, as they could be removed from
the cache if not used often enough, although in reality there are probably unlikely to be vast numbers of cache provider implementation instances, as most applications do not have a massive number of business object or model types.
