This is only really applicable to non-web farm solutions as the data will be stored in process per IIS instance. If you want a distributed solution then look to pay big(ger) bucks or if you are hosting your site in Windows Azure then AppFabric Caching is the go and very reasonably priced. With that disclaimer aside though this works nicely for any single server solution and will cache any type of data.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Runtime.Caching;

// -----------------------------------------------------------------------------
// DataCache: A simple (but effective) caching class
//
// I have been using this code for a while now and thought I would post it out
// to the community as a simple C# DataCache class that can be re-used.
//
// This is only really applicable to non-web farm solutions as the data will be
// stored in process per IIS instance. If you want a distributed solution then
// look to pay big(ger) bucks or if you are hosting your site in Windows Azure
// then AppFabric Caching is the go and very reasonably priced.
//
// With that disclaimer aside though this works nicely for any single server
// solution and will cache any type of data.
//
// I chose to have a DataCacheItem enum for each project I use this on, which is
// one of the parameters to the Insert, Get, Contains and Remove methods but you
// could always change to a string if you like. I prefer the strongly typed
// approach as it saves on typing errors.
//
// Usage is pretty darn simple and there is one overload for each method which
// takes a subKey of type int. This is a bit of a throw back from the first
// project I used it on but subKey always seems to be an ‘int’ for me so I have
// just left it as is. Again, feel free to change this to a more generic type if
// you want to improve the code.
//
// At the end of the code listing is some sample code of how to use the class.
// In this case I have a Home Controller which returns a Home Model. The model
// data rarely changes so is cached for a period of time and returned from the
// cache when available, which in my case will be for 15 minutes. The
// LoadHomeModel() method is a helper function which does all the hard work of
// loading the model.
//
// Hope you find the code useful and if you have any ideas for improvement,
// aside from making the key and subKey more generic, please drop me a line.
//
// If you spot any problems with this implementation I would also love to hear
// from you.
//
// Author: James Coenen-Eyre
// http://zurb.com/forrst/posts/DataCache_T_A_simple_but_effective_caching_c-w4G
// -----------------------------------------------------------------------------

namespace BondiGeek.Code
{
    public enum DataCacheItem
    {
        // These are specific to my implementation.
        // See description below
        LastTweet,
        WeatherReport,
        Toolbox,
        Work,
        Home,
        Blog
    }

    /// <summary>
    /// Library used for arbitrary caching of objects.
    /// </summary>
    public class DataCache
    {
        public static void Insert<T>(DataCacheItem key, T value)
        {
            lock (MemoryCache.Default)
            {
                MemoryCache.Default.Remove(key.ToString());
                DateTimeOffset expires = new DateTimeOffset(DateTime.Now.AddMinutes(Properties.Settings.Default.CacheDurationInMinutes));
                MemoryCache.Default.Add(key.ToString(), value, expires);
            }
        }

        public static void Insert<T>(DataCacheItem key, int subKey, T value)
        {
            lock (MemoryCache.Default)
            {
                MemoryCache.Default.Remove(string.Format("{0}-{1}", key.ToString(), subKey));
                DateTimeOffset expires = new DateTimeOffset(DateTime.Now.AddMinutes(Properties.Settings.Default.CacheDurationInMinutes));
                MemoryCache.Default.Add(string.Format("{0}-{1}", key.ToString(), subKey), value, expires);
            }
        }

        public static T Get<T>(DataCacheItem key)
        {
            if (MemoryCache.Default.Contains(key.ToString()))
            {
                return (T)MemoryCache.Default.Get(key.ToString());
            }
            else
            {
                return default(T);
            }
        }

        public static T Get<T>(DataCacheItem key, int subKey)
        {
            if (MemoryCache.Default.Contains(string.Format("{0}-{1}", key.ToString(), subKey)))
            {
                return (T)MemoryCache.Default.Get(string.Format("{0}-{1}", key.ToString(), subKey));
            }
            else
            {
                return default(T);
            }
        }

        public static bool Contains(DataCacheItem key)
        {
            return MemoryCache.Default.Contains(key.ToString());
        }

        public static bool Contains(DataCacheItem key, int subKey)
        {
            return MemoryCache.Default.Contains(string.Format("{0}-{1}", key.ToString(), subKey));
        }

        public static void Remove(DataCacheItem key)
        {
            MemoryCache.Default.Remove(key.ToString());
        }

        public static void Remove(DataCacheItem key, int subKey)
        {
            MemoryCache.Default.Remove(string.Format("{0}-{1}", key.ToString(), subKey));
        }
    }
}


//
// Usage sample within an MVC Controller
public ActionResult Index()
{
    // Get the data from the cache if available
    if (!DataCache.Contains(DataCacheItem.Home))
    {
        DataCache.Insert<HomeModel>(DataCacheItem.Home, LoadHomeModel());
    }

    return View(DataCache.Get<HomeModel>(DataCacheItem.Home));
}