Cache mechanism for .NET

Question

***Just for learning purpose***

Recently I just knew the word cache and cache mechanism and generally understand that the cache mechanism is a good thing on system responding performance and reduce many interacting with database.

And based on the talking with someone else, they told me the general idea that we can create an independent library and cache the data retrieving from database and once we need it in our business layer, then we can retrieve it from the cache layer.

And they also shared something but not very detailed that the database can update the cache layer automatically when the data in database refreshed, like updating, adding and deleting.

So my questions comes, how does database know and update cache layer proactively and automatically? Can anybody share something with me? or are there any existing frameworks, open source solutions?

I would much appreciate for your kindly help. I'm looking forward to hearing from you my friend.

Answer 1

Try this third party cache: CacheCrow, it is a simple LFU based cache.

Install using powershell command in visual studio: Install-Package CacheCrow

Code Snippet:

// initialization of singleton class
ICacheCrow<string, string> cache = CacheCrow<string, string>.Initialize(1000);

// adding value to cache
cache.Add("#12","Jack");

// searching value in cache
var flag = cache.LookUp("#12");
if(flag)
{
    Console.WriteLine("Found");
}

// removing value
var value = cache.Remove("#12");

For more information you can visit: https://github.com/RishabKumar/CacheCrow

Answer 2

Jacob,

Let me give you an example...

In the data layer when we are going to retrieve a list of objects that should be cached from the database we could to something like this.

if (!CacheHelper.Get("AllRoles", out entities))   
{
var items = _context.Set<Roles>().ToList();
entities = items;
var cachableEntities = entities.ToList();
CacheHelper.Add(cachableEntities, "AllRoles");
}

return entities;

You'll notice that I have Cache helper that will search the cache for the key "AllRoles" if it finds the cache it will return the entities from the cache. If it cant find it it will get the data from the database and Create the cache with the key.

Additionally, every time we add/delete/or change an item in this table we could simple destroy this cache.

CacheHelper.Clear(CacheKey);

So answering the question, in this sample the database doesn't know when to recreate the cache, the application logic does.

Here a sample of a Cache Helpers you may use....

using System;
using System.Collections.Generic;
using System.Web;

namespace Core.Helpers
{
    public static class CacheHelper
    {
        public static List<string> GetCacheKeys()
        {
            List<string> keys = new List<string>();
            // retrieve application Cache enumerator
            var enumerator = System.Web.HttpRuntime.Cache.GetEnumerator();

            while (enumerator.MoveNext())
            {
                keys.Add(enumerator.Key.ToString());
            }

            return keys;
        }

        /// <summary>
        /// Insert value into the cache using
        /// appropriate name/value pairs
        /// </summary>
        /// <typeparam name="T">Type of cached item</typeparam>
        /// <param name="o">Item to be cached</param>
        /// <param name="key">Name of item</param>
        public static void Add<T>(T o, string key)
        {
            // NOTE: Apply expiration parameters as you see fit.
            // I typically pull from configuration file.

            // In this example, I want an absolute
            // timeout so changes will always be reflected
            // at that time. Hence, the NoSlidingExpiration.
            if (HttpContext.Current != null)
            HttpContext.Current.Cache.Insert(
                key,
                o,
                null,
                DateTime.Now.AddMinutes(1440),
                System.Web.Caching.Cache.NoSlidingExpiration);
        }

        /// <summary>
        /// Remove item from cache
        /// </summary>
        /// <param name="key">Name of cached item</param>
        public static void Clear(string key)
        {
            if (HttpContext.Current != null)
            HttpContext.Current.Cache.Remove(key);
        }

        /// <summary>
        /// Check for item in cache
        /// </summary>
        /// <param name="key">Name of cached item</param>
        /// <returns></returns>
        public static bool Exists(string key)
        {
            var exists= HttpContext.Current != null && HttpContext.Current.Cache[key] != null;
            return exists;
        }

        /// <summary>
        /// Retrieve cached item
        /// </summary>
        /// <typeparam name="T">Type of cached item</typeparam>
        /// <param name="key">Name of cached item</param>
        /// <param name="value">Cached value. Default(T) if
        /// item doesn't exist.</param>
        /// <returns>Cached item as type</returns>
        public static bool Get<T>(string key, out T value)
        {
            try
            {
                if (!Exists(key))
                {
                    value = default(T);
                    return false;
                }

                value = (T)HttpContext.Current.Cache[key];
            }
            catch
            {
                value = default(T);
                return false;
            }

            return true;
        }
    }
}