Originally posted on: http://geekswithblogs.net/EltonStoneman/archive/2013/10/22/sixeyed.caching-available-now-on-nuget-and-github.aspx

The good guys at Pluralsight have okayed me to publish my caching framework (as seen in Caching in the .NET Stack: Inside-Out) as an open-source library, and it’s out now.

You can get it here: Sixeyed.Caching source code on GitHub, and here: Sixeyed.Caching package v1.0.0 on NuGet.

If you haven’t seen the course, there’s a preview here on YouTube: In-Process and Out-of-Process Caches, which gives a good flavour.

The library is a wrapper around various cache providers, including the .NET MemoryCache, AppFabric cache, and  memcached*. All the wrappers inherit from a base class which gives you a set of common functionality against all the cache implementations:

•    inherits OutputCacheProvider, so you can use your chosen cache provider as an ASP.NET output cache;
•    serialization and encryption, so you can configure whether you want your cache items serialized (XML, JSON or binary) and encrypted;
•    instrumentation, you can optionally use performance counters to monitor cache attempts and hits, at a low level.

The framework wraps up different caches into an ICache interface, and it lets you use a provider directly like this:

  Cache.Memory.Get<RefData>(refDataKey);

- or with configuration to use the default cache provider:

   Cache.Default.Get<RefData>(refDataKey);

The library uses Unity’s interception framework to implement AOP caching, which you can use by flagging methods with the [Cache] attribute:

   [Cache] 
   public RefData GetItem(string refDataKey)

- and you can be more specific on the required cache behaviour:

   [Cache(CacheType=CacheType.Memory, Days=1] 
   public RefData GetItem(string refDataKey)

- or really specific:

   [Cache(CacheType=CacheType.Disk, SerializationFormat=SerializationFormat.Json, Hours=2, Minutes=59)] 
   public RefData GetItem(string refDataKey)

Provided you get instances of classes with cacheable methods from the container, the attributed method results will be cached, and repeated calls will be fetched from the cache.

You can also set a bunch of cache defaults in application config, like whether to use encryption and instrumentation, and whether the cache system is enabled at all:

   <sixeyed.caching enabled="true"> 
    <performanceCounters instrumentCacheTotalCounts="true" 
                            instrumentCacheTargetCounts="true" 
                            categoryNamePrefix ="Sixeyed.Caching.Tests"/> 
    <encryption enabled="true" 
                   key="1234567890abcdef1234567890abcdef" 
                   iv="1234567890abcdef"/> <!-- key must be 32 characters, IV must be 16 characters--> 
   </sixeyed.caching>

For AOP and methods flagged with the cache attribute, you can override the compile-time cache settings at runtime with more config (keyed by the class and method name):

   <sixeyed.caching enabled="true"> 
    <targets> 
     <target keyPrefix="MethodLevelCachingStub.GetRandomIntCacheConfiguredInternal" enabled="false"/> 
     <target keyPrefix="MethodLevelCachingStub.GetRandomIntCacheExpiresConfiguredInternal" seconds="1"/> 
    </targets>

It’s released under the MIT license, so you can use it freely in your own apps and modify as required.

I’ll be adding more content to the GitHub wiki, which will be the main source of documentation, but for now there’s an FAQ to get you started.

* - in the course the framework library also wraps NCache Express, but there's no public redistributable library that I can find, so it's not in Sixeyed.Caching.