Reader Level:
ARTICLE

Custom CacheManager Implementation for Windows/Console applications

Posted by Chandramouli Muralidaran Articles | Design & Architecture September 30, 2009
Mainly the term caching is used in web applications environments to store commonly used database values.
  • 0
  • 0
  • 8164

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;

                }

                catch (ArgumentException argumentException)

                {

                    throw argumentException;

                }

            }

            return bResult;

        }

 

        /// <summary>

        /// <remarks>This function remove the given key from Dictionary</remarks>

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

        /// <returns>Boolean</returns>

        /// </summary>

 

        public static Boolean Remove(string key)

        {

            Boolean Result = false;

 

            lock (Cache)

            {

                try

                {

                    if (Cache.ContainsKey(key.Trim()))

                    {

                        Cache.Remove(key.Trim());

                        Result = true;

                    }

                    else

                    {

                        Result = false;

                    }

                }

                catch (ArgumentNullException argumentNullException)

                {

                    throw argumentNullException;

                }

            }

            return Result;

        }

 

        /// <summary>

        /// <remarks>This function gets the object for the given key</remarks>

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

        /// <returns>Boolean</returns>

        /// </summary>

 

        public static object Get(string key)

        {

            object ReturnObject = null;

 

            try

            {

                Cache.TryGetValue(key.Trim(), out ReturnObject);

            }

            catch (ArgumentNullException argumentNullException)

            {

                throw argumentNullException;

            }

            catch (KeyNotFoundException keyNotFoundException)

            {

                throw keyNotFoundException;

            }

            return ReturnObject;

        }

 

        /// <summary>

        /// <remarks>This function checks for the given key</remarks>

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

        /// <returns>Boolean</returns>

        /// </summary>

 

        public static Boolean IsExists(string key)

        {

            return Cache.ContainsKey(key.Trim());

        }

 

        /// <summary>

        /// Clears all avaialble keys and values in the cache

        /// </summary>

        public static void Flush()

        {

            try

            {

                Cache.Clear();

            }

            catch (Exception excp)

            {

                throw excp;

            }

        }

 

        #endregion

 

    }
 

COMMENT USING