Custom CacheManager Implementation for Windows/Console applications

Introduction

Mainly the term caching is used in web applications environments to store commonly used database values. By caching this information rather than relying on repeated database calls, decreases the demand on the Web server and database server's system resources and the Web application's scalability is increased. In ASP .Net Web applications, caching is used to retain pages or data across HTTP requests and reuse them.

.Net Framework exposes lot of methodologies and classes to maintain data in memory. But they can be used only in ASP .Net web applications. A windows application is NOT a stateless model as ASP .Net. There are very limited options to store data in Windows / console applications. This article discusses few techniques in maintaining data in memory for quick access. A sample CacheManager implementation is shown with this article for C# Console/Windows applications usage.

Caching Techniques

One option to retain the data is to declare the objects / members at the class level. It is always available until the object is destroyed or the object goes out of scope. It is good to have a storage where in application can drop any objects into and use it any time they want. Here I've tried building a generic Cache Manager component in C#.

Cache Manager

Here, objective is to build a storage rack where consumers of the component can add, locate and remove any objects by a user defined key. Cache Manager the holder of the storage is responsible for adding and maintaining objects till the application is running. Objects that stored in the rack can be shared by different consumers if the key is known.

Key design considerations are -

1. Cache and objects that are put in should be made available till the application runs

2. Ability to store one or more elements in the storage

3. CacheManager object should be in memory even if it is out of scope

4. Objects in the cache should be sharable across different users

5. Objects should be added or identified by an Unique key

6. Synchronized access should be ensured while adding object

Fundamentals behind the Design

To store more elements, array like structure is used. This helps the CacheManager to add one or more objects. Identifying or searching the objects in the array is not viable thing. It would be good to have objects located by a name(key). This makes searching easier and lot quicker. .Net provides different Collection objects to achieve the same. CacheManager uses Dictionary class to maintain Key, Value pair collections to implement the storage rack.

Next big challenge here is keeping the CacheManager available till the application runs. This is achieved by creating the class with "static" members. Static objects are created in the stack and will be available till the application handle that created this object or appdomain is alive. Static objects also helps in sharing the same object instance as it is stored in stack. This gives us a great flexibility to share the storage rack and objects to different consumers.

A Dictionary (collecttion key value pair) is created to add the objects that are to be cached. This Dictionary object is created as static member to ensure only one instance of the Dictionary object is created for different calls. Since the Dictionary is made as static objects that are added to the cache will stay alive till the life time of the appdomain.

Also to avoid object creation from the client, declared a private constructor. This step may not be essential as the Dictionary itself is static.

Below is the Cache Manager Code snippet

public class CacheManager

{

#region Static Variable

// Private static variable which holds the key value pair

private static Dictionary<string, object> Cache = new Dictionary<string, object>();

#endregion

private CacheManager()

{

}

#region Public Methods

/// <summary>

/// <remarks>This function addeds the given object in the Dictionary object</remarks>

/// <param name="key"></param>

/// <param name="value"></param>

/// <returns>Boolean</returns>

/// </summary>

public static Boolean Add(string key, object value)

{

bool bResult = false;

lock (Cache)

{

try

{

Cache.Add(key.Trim(), value);

bResult = true;

}

catch (ArgumentNullException argumentNullException)

{

throw argumentNullException;