Worked on the application cache, added request cache, changed some stuff over to be interfaces, added unit tests suite (need mroe) to test all caching providers.

Conflicts:
	src/Umbraco.Core/Cache/CacheProviderBase.cs
	src/Umbraco.Core/Cache/HttpRuntimeCacheProvider.cs
	src/Umbraco.Core/Cache/NullCacheProvider.cs
	src/Umbraco.Core/Cache/StaticCacheProvider.cs

src/Umbraco.Core/Cache/CacheProviderBase.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Cache
-{
-    /// <summary>
-    /// An abstract class for implementing a basic cache provider
-    /// </summary>
-    /// <remarks>
-    /// THIS MUST REMAIN INTERNAL UNTIL WE STREAMLINE HOW ALL CACHE IS HANDLED, WE NEED TO SUPPORT HTTP RUNTIME CACHE, IN MEMORY CACHE, ETC...
-    /// </remarks>
-    internal abstract class CacheProviderBase
-    {
-        public abstract void ClearAllCache();
-        public abstract void ClearCacheItem(string key);
-        public abstract void ClearCacheObjectTypes(string typeName);
-        public abstract void ClearCacheObjectTypes<T>();
-        public abstract void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate);
-        public abstract void ClearCacheByKeySearch(string keyStartsWith);
-        public abstract void ClearCacheByKeyExpression(string regexString);
-        public abstract IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith);
-        public abstract T GetCacheItem<T>(string cacheKey);
-        public abstract T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem);
-    }
-}

src/Umbraco.Core/Cache/DictionaryCacheProdiverBase.cs

@@ -0,0 +1,178 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace Umbraco.Core.Cache
+{
+    internal abstract class DictionaryCacheProdiverBase : ICacheProvider
+    {
+        private static readonly object Locker = new object();
+        protected abstract DictionaryCacheWrapper DictionaryCache { get; }
+
+        /// <summary>
+        /// Clears everything in umbraco's runtime cache
+        /// </summary>
+        /// <remarks>
+        /// Does not clear other stuff the user has put in httpruntime.cache!
+        /// </remarks>
+        public virtual void ClearAllCache()
+        {
+            lock (Locker)
+            {
+                var keysToRemove = DictionaryCache.Cast<object>()
+                                                  .Select(item => new DictionaryItemWrapper(item))
+                                                  .Where(c => c.Key is string && ((string)c.Key).StartsWith(CacheItemPrefix) && DictionaryCache[c.Key.ToString()] != null)
+                                                  .Select(c => c.Key)
+                                                  .ToList();
+
+                foreach (var k in keysToRemove)
+                {
+                    DictionaryCache.Remove(k);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Clears the item in umbraco's runtime cache with the given key 
+        /// </summary>
+        /// <param name="key">Key</param>
+        public virtual void ClearCacheItem(string key)
+        {
+            lock (Locker)
+            {
+                if (DictionaryCache[GetCacheKey(key)] == null) return;
+                DictionaryCache.Remove(GetCacheKey(key)); ;
+            }
+        }
+
+        /// <summary>
+        /// Clears all objects in the System.Web.Cache with the System.Type name as the
+        /// input parameter. (using [object].GetType())
+        /// </summary>
+        /// <param name="typeName">The name of the System.Type which should be cleared from cache ex "System.Xml.XmlDocument"</param>
+        public virtual void ClearCacheObjectTypes(string typeName)
+        {
+            lock (Locker)
+            {
+                var keysToRemove = DictionaryCache.Cast<object>()
+                                                  .Select(item => new DictionaryItemWrapper(item))
+                                                  .Where(c => DictionaryCache[c.Key.ToString()] != null && DictionaryCache[c.Key.ToString()].GetType().ToString().InvariantEquals(typeName))
+                                                  .Select(c => c.Key)
+                                                  .ToList();
+
+                foreach (var k in keysToRemove)
+                {
+                    DictionaryCache.Remove(k);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Clears all objects in the System.Web.Cache with the System.Type specified
+        /// </summary>
+        public virtual void ClearCacheObjectTypes<T>()
+        {            
+            lock (Locker)
+            {
+                var keysToRemove = DictionaryCache.Cast<object>()
+                                                  .Select(item => new DictionaryItemWrapper(item))
+                                                  .Where(c => DictionaryCache[c.Key.ToString()] != null && DictionaryCache[c.Key.ToString()].GetType() == typeof (T))
+                                                  .Select(c => c.Key)
+                                                  .ToList();
+
+                foreach (var k in keysToRemove)
+                {
+                    DictionaryCache.Remove(k);    
+                }
+                    
+            }
+        }
+
+        /// <summary>
+        /// Clears all cache items that starts with the key passed.
+        /// </summary>
+        /// <param name="keyStartsWith">The start of the key</param>
+        public virtual void ClearCacheByKeySearch(string keyStartsWith)
+        {
+            var keysToRemove = DictionaryCache.Cast<object>()
+                                              .Select(item => new DictionaryItemWrapper(item))
+                                              .Where(c => c.Key is string && ((string)c.Key).InvariantStartsWith(string.Format("{0}-{1}", CacheItemPrefix, keyStartsWith)))
+                                              .Select(c => c.Key)
+                                              .ToList();
+
+            foreach (var k in keysToRemove)
+            {
+                DictionaryCache.Remove(k);
+            }
+        }
+
+        /// <summary>
+        /// Clears all cache items that have a key that matches the regular expression
+        /// </summary>
+        /// <param name="regexString"></param>
+        public virtual void ClearCacheByKeyExpression(string regexString)
+        {
+            var keysToRemove = new List<object>();
+            foreach (var item in DictionaryCache)
+            {
+                var c = new DictionaryItemWrapper(item);
+                var s = c.Key as string;
+                if (s != null)
+                {
+                    var withoutPrefix = s.TrimStart(string.Format("{0}-", CacheItemPrefix));
+                    if (Regex.IsMatch(withoutPrefix, regexString))
+                    {
+                        keysToRemove.Add(c.Key);
+                    }
+                }
+            }
+
+            foreach (var k in keysToRemove)
+            {
+                DictionaryCache.Remove(k);
+            }
+        }
+
+        public virtual IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
+        {
+            return (from object item in DictionaryCache
+                    select new DictionaryItemWrapper(item)
+                    into c
+                    where c.Key is string && ((string) c.Key).InvariantStartsWith(string.Format("{0}-{1}", CacheItemPrefix, keyStartsWith))
+                    select c.Value.TryConvertTo<T>()
+                    into converted
+                    where converted.Success
+                    select converted.Result).ToList();
+        }
+
+        /// <summary>
+        /// Returns a cache item by key, does not update the cache if it isn't there.
+        /// </summary>
+        /// <typeparam name="TT"></typeparam>
+        /// <param name="cacheKey"></param>
+        /// <returns></returns>
+        public virtual TT GetCacheItem<TT>(string cacheKey)
+        {
+            var result = DictionaryCache.Get(GetCacheKey(cacheKey));
+            if (result == null)
+            {
+                return default(TT);
+            }
+            return result.TryConvertTo<TT>().Result;
+        }
+
+        public abstract T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem);        
+
+        /// <summary>
+        /// We prefix all cache keys with this so that we know which ones this class has created when 
+        /// using the HttpRuntime cache so that when we clear it we don't clear other entries we didn't create.
+        /// </summary>
+        protected const string CacheItemPrefix = "umbrtmche";
+
+        protected string GetCacheKey(string key)
+        {
+            return string.Format("{0}-{1}", CacheItemPrefix, key);
+        }
+    }
+}

src/Umbraco.Core/Cache/DictionaryCacheWrapper.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections;
+
+namespace Umbraco.Core.Cache
+{
+    internal class DictionaryCacheWrapper : IEnumerable
+    {
+        private readonly IEnumerable _inner;
+        private readonly Func<object, object> _get;
+        private readonly Action<object> _remove;
+
+        public DictionaryCacheWrapper(
+            IEnumerable inner,
+            Func<object, object> get,
+            Action<object> remove)
+        {
+            _inner = inner;
+            _get = get;
+            _remove = remove;
+        }
+
+        public object this[object key]
+        {
+            get
+            {
+                return Get(key);
+            }            
+        }
+
+        public object Get(object key)
+        {
+            return _get(key);
+        }
+
+        public void Remove(object key)
+        {
+            _remove(key);
+        }
+
+        public IEnumerator GetEnumerator()
+        {
+            return _inner.GetEnumerator();
+        }
+    }
+}

src/Umbraco.Core/Cache/DictionaryItemWrapper.cs

@@ -0,0 +1,14 @@
+namespace Umbraco.Core.Cache
+{
+    internal class DictionaryItemWrapper
+    {
+        public DictionaryItemWrapper(dynamic item)
+        {
+            Key = item.Key;
+            Value = item.Value;
+        }
+        
+        public object Key { get; private set; }
+        public object Value { get; private set; }
+    }
+}

src/Umbraco.Core/Cache/HttpRequestCacheProvider.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Web;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// A cache provider that caches items in the HttpContext.Items
+    /// </summary>
+    internal class HttpRequestCacheProvider : DictionaryCacheProdiverBase
+    {
+        private readonly Func<HttpContextBase> _context;
+
+        public HttpRequestCacheProvider(HttpContext context)
+        {
+            _context = () => new HttpContextWrapper(context);
+        }
+
+        public HttpRequestCacheProvider(Func<HttpContextBase> context)
+        {
+            _context = context;
+        }
+
+        protected override DictionaryCacheWrapper DictionaryCache
+        {
+            get
+            {
+                var ctx = _context();
+                return new DictionaryCacheWrapper(
+                    ctx.Items,
+                    o => ctx.Items[o],
+                    o => ctx.Items.Remove(o));
+            }
+        }
+
+        public override T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
+        {
+            var ctx = _context();
+            var ck = GetCacheKey(cacheKey);
+            if (ctx.Items[ck] == null)
+            {
+                ctx.Items[ck] = getCacheItem();
+            }
+            return (T)ctx.Items[ck];
+        }
+    }
+}

src/Umbraco.Core/Cache/HttpRuntimeCacheProvider.cs

@@ -1,109 +1,27 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.RegularExpressions;
+using System.Web;
 using System.Web.Caching;
 using Umbraco.Core.Logging;
+using CacheItemPriority = System.Web.Caching.CacheItemPriority;
 
 namespace Umbraco.Core.Cache
 {
     /// <summary>
     /// A CacheProvider that wraps the logic of the HttpRuntime.Cache
     /// </summary>
-    internal class HttpRuntimeCacheProvider : RuntimeCacheProviderBase
+    internal class HttpRuntimeCacheProvider : DictionaryCacheProdiverBase, IRuntimeCacheProvider
     {
         private readonly System.Web.Caching.Cache _cache;
+        private readonly DictionaryCacheWrapper _wrapper;
         private static readonly object Locker = new object();
-
+        
         public HttpRuntimeCacheProvider(System.Web.Caching.Cache cache)
         {
             _cache = cache;
+            _wrapper = new DictionaryCacheWrapper(_cache, s => _cache.Get(s.ToString()), o => _cache.Remove(o.ToString()));
         }
 
-        /// <summary>
-        /// Clears everything in umbraco's runtime cache, which means that not only
-        /// umbraco content is removed, but also other cache items from pages running in
-        /// the same application / website. Use with care :-)
-        /// </summary>
-        public override void ClearAllCache()
-        {
-            var cacheEnumerator = _cache.GetEnumerator();
-            while (cacheEnumerator.MoveNext())
-            {
-                _cache.Remove(cacheEnumerator.Key.ToString());
-            }
-        }
-
-        /// <summary>
-        /// Clears the item in umbraco's runtime cache with the given key 
-        /// </summary>
-        /// <param name="key">Key</param>
-        public override void ClearCacheItem(string key)
-        {
-            // NH 10 jan 2012
-            // Patch by the always wonderful Stéphane Gay to avoid cache null refs
-            lock (Locker)
-            {
-                if (_cache[key] == null) return;
-                _cache.Remove(key); ;
-            }
-        }
-
-
-        /// <summary>
-        /// Clears all objects in the System.Web.Cache with the System.Type name as the
-        /// input parameter. (using [object].GetType())
-        /// </summary>
-        /// <param name="typeName">The name of the System.Type which should be cleared from cache ex "System.Xml.XmlDocument"</param>
-        public override void ClearCacheObjectTypes(string typeName)
-        {
-            try
-            {
-                lock (Locker)
-                {
-                    foreach (DictionaryEntry c in _cache)
-                    {
-                        if (_cache[c.Key.ToString()] != null
-                            && _cache[c.Key.ToString()].GetType().ToString().InvariantEquals(typeName))
-                        {
-                            _cache.Remove(c.Key.ToString());
-                        }
-                    }
-                }
-            }
-            catch (Exception e)
-            {
-                LogHelper.Error<CacheHelper>("Cache clearing error", e);
-            }
-        }
-
-        /// <summary>
-        /// Clears all objects in the System.Web.Cache with the System.Type specified
-        /// </summary>
-        public override void ClearCacheObjectTypes<T>()
-        {
-            try
-            {
-                lock (Locker)
-                {
-                    foreach (DictionaryEntry c in _cache)
-                    {
-                        if (_cache[c.Key.ToString()] != null
-                            && _cache[c.Key.ToString()].GetType() == typeof(T))
-                        {
-                            _cache.Remove(c.Key.ToString());
-                        }
-                    }
-                }
-            }
-            catch (Exception e)
-            {
-                LogHelper.Error<CacheHelper>("Cache clearing error", e);
-            }
-        }
-
-        /// <summary>
+        protected override DictionaryCacheWrapper DictionaryCache
         /// Clears all objects in the System.Web.Cache with the System.Type specified that satisfy the predicate
         /// </summary>
         public override void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
@@ -131,69 +49,18 @@ namespace Umbraco.Core.Cache
         }
 
         /// <summary>
-        /// Clears all cache items that starts with the key passed.
-        /// </summary>
-        /// <param name="keyStartsWith">The start of the key</param>
-        public override void ClearCacheByKeySearch(string keyStartsWith)
         {
-            foreach (DictionaryEntry c in _cache)
-            {
-                if (c.Key is string && ((string)c.Key).InvariantStartsWith(keyStartsWith))
-                {
-                    ClearCacheItem((string)c.Key);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Clears all cache items that have a key that matches the regular expression
-        /// </summary>
-        /// <param name="regexString"></param>
-        public override void ClearCacheByKeyExpression(string regexString)
-        {
-            foreach (DictionaryEntry c in _cache)
-            {
-                if (c.Key is string && Regex.IsMatch(((string)c.Key), regexString))
-                {
-                    ClearCacheItem((string)c.Key);
-                }
-            }
-        }
-
-        public override IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
-        {
-            return (from DictionaryEntry c in _cache
-                    where c.Key is string && ((string)c.Key).InvariantStartsWith(keyStartsWith)
-                    select c.Value.TryConvertTo<T>()
-                    into attempt
-                    where attempt.Success
-                    select attempt.Result).ToList();
-        }
-
-        /// <summary>
-        /// Returns a cache item by key, does not update the cache if it isn't there.
-        /// </summary>
-        /// <typeparam name="TT"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey)
-        {
-            var result = _cache.Get(cacheKey);
-            if (result == null)
-            {
-                return default(TT);
-            }
-            return result.TryConvertTo<TT>().Result;
+            get { return _wrapper; }
         }
 
         /// <summary>
         /// Gets (and adds if necessary) an item from the cache with all of the default parameters
         /// </summary>
-        /// <typeparam name="TT"></typeparam>
+        /// <typeparam name="T"></typeparam>
         /// <param name="cacheKey"></param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey, Func<TT> getCacheItem)
+        public override T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
         {
             return GetCacheItem(cacheKey, CacheItemPriority.Normal, null, null, null, getCacheItem, Locker);
         }
@@ -206,7 +73,7 @@ namespace Umbraco.Core.Cache
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey,
+        public virtual TT GetCacheItem<TT>(string cacheKey,
                                             TimeSpan? timeout, Func<TT> getCacheItem)
         {
             return GetCacheItem(cacheKey, null, timeout, getCacheItem);
@@ -221,7 +88,7 @@ namespace Umbraco.Core.Cache
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey,
+        public virtual TT GetCacheItem<TT>(string cacheKey,
                                             CacheItemRemovedCallback refreshAction, TimeSpan? timeout,
                                             Func<TT> getCacheItem)
         {
@@ -238,7 +105,7 @@ namespace Umbraco.Core.Cache
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey,
+        public virtual TT GetCacheItem<TT>(string cacheKey,
                                             CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout,
                                             Func<TT> getCacheItem)
         {
@@ -256,7 +123,7 @@ namespace Umbraco.Core.Cache
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey,
+        public virtual TT GetCacheItem<TT>(string cacheKey,
                                             CacheItemPriority priority,
                                             CacheItemRemovedCallback refreshAction,
                                             CacheDependency cacheDependency,
@@ -282,12 +149,14 @@ namespace Umbraco.Core.Cache
                                      CacheItemPriority priority, CacheItemRemovedCallback refreshAction,
                                      CacheDependency cacheDependency, TimeSpan? timeout, Func<TT> getCacheItem, object syncLock)
         {
-            var result = _cache.Get(cacheKey);
+            cacheKey = GetCacheKey(cacheKey);
+
+            var result = DictionaryCache.Get(cacheKey);
             if (result == null)
             {
                 lock (syncLock)
                 {
-                    result = _cache.Get(cacheKey);
+                    result = DictionaryCache.Get(cacheKey);
                     if (result == null)
                     {
                         result = getCacheItem();
@@ -311,7 +180,7 @@ namespace Umbraco.Core.Cache
         /// <param name="cacheKey"></param>
         /// <param name="priority"></param>
         /// <param name="getCacheItem"></param>
-        public override void InsertCacheItem<T>(string cacheKey,
+        public virtual void InsertCacheItem<T>(string cacheKey,
                                                 CacheItemPriority priority,
                                                 Func<T> getCacheItem)
         {
@@ -326,7 +195,7 @@ namespace Umbraco.Core.Cache
         /// <param name="priority"></param>
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
-        public override void InsertCacheItem<T>(string cacheKey,
+        public virtual void InsertCacheItem<T>(string cacheKey,
                                                 CacheItemPriority priority,
                                                 TimeSpan? timeout,
                                                 Func<T> getCacheItem)
@@ -343,7 +212,7 @@ namespace Umbraco.Core.Cache
         /// <param name="cacheDependency"></param>
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
-        public override void InsertCacheItem<T>(string cacheKey,
+        public virtual void InsertCacheItem<T>(string cacheKey,
                                                 CacheItemPriority priority,
                                                 CacheDependency cacheDependency,
                                                 TimeSpan? timeout,
@@ -362,7 +231,7 @@ namespace Umbraco.Core.Cache
         /// <param name="cacheDependency"></param>
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
-        public override void InsertCacheItem<T>(string cacheKey,
+        public virtual void InsertCacheItem<T>(string cacheKey,
                                                 CacheItemPriority priority,
                                                 CacheItemRemovedCallback refreshAction,
                                                 CacheDependency cacheDependency,
@@ -372,6 +241,8 @@ namespace Umbraco.Core.Cache
             object result = getCacheItem();
             if (result != null)
             {
+                cacheKey = GetCacheKey(cacheKey);
+
                 //we use Insert instead of add if for some crazy reason there is now a cache with the cache key in there, it will just overwrite it.
                 _cache.Insert(cacheKey, result, cacheDependency,
                               timeout == null ? System.Web.Caching.Cache.NoAbsoluteExpiration : DateTime.Now.Add(timeout.Value),

src/Umbraco.Core/Cache/ICacheProvider.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// An abstract class for implementing a basic cache provider
+    /// </summary>
+    /// <remarks>
+    /// THIS MUST REMAIN INTERNAL UNTIL WE STREAMLINE HOW ALL CACHE IS HANDLED, WE NEED TO SUPPORT HTTP RUNTIME CACHE, IN MEMORY CACHE, ETC...
+    /// </remarks>
+    internal interface ICacheProvider
+    {
+        void ClearAllCache();
+        void ClearCacheItem(string key);
+        void ClearCacheObjectTypes(string typeName);
+        void ClearCacheObjectTypes<T>();
+        void ClearCacheByKeySearch(string keyStartsWith);
+        void ClearCacheByKeyExpression(string regexString);
+        IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith);
+        T GetCacheItem<T>(string cacheKey);
+        T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem);
+    }
+}

src/Umbraco.Core/Cache/IRuntimeCacheProvider.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Text;
+using System.Web.Caching;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// An abstract class for implementing a runtime cache provider
+    /// </summary>
+    /// <remarks>
+    /// THIS MUST REMAIN INTERNAL UNTIL WE STREAMLINE HOW ALL CACHE IS HANDLED, WE NEED TO SUPPORT HTTP RUNTIME CACHE, IN MEMORY CACHE, REQUEST CACHE, ETC...
+    /// </remarks>
+    internal interface IRuntimeCacheProvider : ICacheProvider
+    {
+        T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem);
+        T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
+        T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
+        T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
+        void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem);
+        void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem);
+        void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
+        void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
+    }
+}

src/Umbraco.Core/Cache/NullCacheProvider.cs

@@ -5,21 +5,21 @@ using System.Web.Caching;
 
 namespace Umbraco.Core.Cache
 {
-    internal class NullCacheProvider : RuntimeCacheProviderBase
+    internal class NullCacheProvider : IRuntimeCacheProvider
     {
-        public override void ClearAllCache()
+        public virtual void ClearAllCache()
         {
         }
 
-        public override void ClearCacheItem(string key)
+        public virtual void ClearCacheItem(string key)
         {
         }
 
-        public override void ClearCacheObjectTypes(string typeName)
+        public virtual void ClearCacheObjectTypes(string typeName)
         {
         }
 
-        public override void ClearCacheObjectTypes<T>()
+        public virtual void ClearCacheObjectTypes<T>()
         {
         }
 
@@ -31,58 +31,58 @@ namespace Umbraco.Core.Cache
         {
         }
 
-        public override void ClearCacheByKeyExpression(string regexString)
+        public virtual void ClearCacheByKeyExpression(string regexString)
         {
         }
 
-        public override IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
+        public virtual IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
         {
             return Enumerable.Empty<T>();
         }
 
-        public override T GetCacheItem<T>(string cacheKey)
+        public virtual T GetCacheItem<T>(string cacheKey)
         {
             return default(T);
         }
 
-        public override T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
+        public virtual T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
         {
             return getCacheItem();
         }
 
-        public override T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem)
+        public virtual T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem)
         {
             return getCacheItem();
         }
 
-        public override T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem)
+        public virtual T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem)
         {
             return getCacheItem();
         }
 
-        public override T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem)
+        public virtual T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem)
         {
             return getCacheItem();
         }
 
-        public override T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
+        public virtual T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
         {
             return getCacheItem();
         }
 
-        public override void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem)
+        public virtual void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem)
         {
         }
 
-        public override void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem)
+        public virtual void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem)
         {
         }
 
-        public override void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
+        public virtual void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
         {
         }
 
-        public override void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
+        public virtual void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
         {
         }
     }

src/Umbraco.Core/Cache/ObjectCacheRuntimeCacheProvider.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.Caching;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Web.Caching;
+using Umbraco.Core.Logging;
+using CacheItemPriority = System.Web.Caching.CacheItemPriority;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// A cache provider that wraps the logic of a System.Runtime.Caching.ObjectCache
+    /// </summary>
+    internal class ObjectCacheRuntimeCacheProvider : IRuntimeCacheProvider
+    {
+        private static readonly ReaderWriterLockSlim ClearLock = new ReaderWriterLockSlim();
+        internal ObjectCache MemoryCache;
+
+        public ObjectCacheRuntimeCacheProvider()
+        {
+            MemoryCache = new MemoryCache("in-memory");
+        }
+
+        public virtual void ClearAllCache()
+        {
+            using (new WriteLock(ClearLock))
+            {
+                MemoryCache.DisposeIfDisposable();
+                MemoryCache = new MemoryCache("in-memory");
+            }
+        }
+
+        public virtual void ClearCacheItem(string key)
+        {
+            using (new WriteLock(ClearLock))
+            {
+                if (MemoryCache[key] == null) return;
+                MemoryCache.Remove(key);
+            }            
+        }
+
+        public virtual void ClearCacheObjectTypes(string typeName)
+        {
+            using (new WriteLock(ClearLock))
+            {
+                var keysToRemove = (from c in MemoryCache where c.Value.GetType().ToString().InvariantEquals(typeName) select c.Key).ToList();
+                foreach (var k in keysToRemove)
+                {
+                    MemoryCache.Remove(k);
+                }
+            }
+        }
+
+        public virtual void ClearCacheObjectTypes<T>()
+        {
+            using (new WriteLock(ClearLock))
+            {
+                var keysToRemove = (from c in MemoryCache where c.Value.GetType() == typeof (T) select c.Key).ToList();
+                foreach (var k in keysToRemove)
+                {
+                    MemoryCache.Remove(k);
+                }
+            }
+        }
+
+        public virtual void ClearCacheByKeySearch(string keyStartsWith)
+        {
+            using (new WriteLock(ClearLock))
+            {
+                var keysToRemove = (from c in MemoryCache where c.Key.InvariantStartsWith(keyStartsWith) select c.Key).ToList();
+                foreach (var k in keysToRemove)
+                {
+                    MemoryCache.Remove(k);
+                }
+            }            
+        }
+
+        public virtual void ClearCacheByKeyExpression(string regexString)
+        {
+            using (new WriteLock(ClearLock))
+            {
+                var keysToRemove = (from c in MemoryCache where Regex.IsMatch(c.Key, regexString) select c.Key).ToList();
+                foreach (var k in keysToRemove)
+                {
+                    MemoryCache.Remove(k);
+                }
+            }     
+        }
+
+        public virtual IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
+        {
+            return (from c in MemoryCache
+                    where c.Key.InvariantStartsWith(keyStartsWith)
+                    select c.Value.TryConvertTo<T>()
+                        into attempt
+                        where attempt.Success
+                        select attempt.Result).ToList();
+        }
+
+        public virtual T GetCacheItem<T>(string cacheKey)
+        {
+            var result = MemoryCache.Get(cacheKey);
+            if (result == null)
+            {
+                return default(T);
+            }
+            return result.TryConvertTo<T>().Result;
+        }
+
+        public virtual T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
+        {
+            return GetCacheItem(cacheKey, CacheItemPriority.Normal, null, null, null, getCacheItem);
+        }
+
+        public virtual T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem)
+        {
+            return GetCacheItem(cacheKey, null, timeout, getCacheItem);
+        }
+
+        public virtual T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem)
+        {
+            return GetCacheItem(cacheKey, CacheItemPriority.Normal, refreshAction, timeout, getCacheItem);
+        }
+
+        public virtual T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem)
+        {
+            return GetCacheItem(cacheKey, priority, refreshAction, null, timeout, getCacheItem);
+        }
+
+        public virtual T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
+        {
+            using (var lck = new UpgradeableReadLock(ClearLock))
+            {
+                var result = MemoryCache.Get(cacheKey);
+                if (result == null)
+                {
+                    lck.UpgradeToWriteLock();
+
+                    result = getCacheItem();
+                    if (result != null)
+                    {
+                        var policy = new CacheItemPolicy
+                            {
+                                AbsoluteExpiration = timeout == null ? ObjectCache.InfiniteAbsoluteExpiration : DateTime.Now.Add(timeout.Value),
+                                SlidingExpiration = TimeSpan.Zero
+                            };
+                        
+                        //TODO: CUrrently we cannot implement this in this provider, we'll have to change the underlying interface
+                        // to accept an array of files instead of CacheDependency.
+                        //policy.ChangeMonitors.Add(new HostFileChangeMonitor(cacheDependency.));
+
+                        MemoryCache.Set(cacheKey, result, policy);
+                    }
+                }
+                return result.TryConvertTo<T>().Result;
+            }
+        }
+
+        public virtual void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem)
+        {
+            InsertCacheItem(cacheKey, priority, null, null, null, getCacheItem);
+        }
+
+        public virtual void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem)
+        {
+            InsertCacheItem(cacheKey, priority, null, null, timeout, getCacheItem);
+        }
+
+        public virtual void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
+        {
+            InsertCacheItem(cacheKey, priority, null, cacheDependency, timeout, getCacheItem);
+        }
+
+        public virtual void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
+        {
+            object result = getCacheItem();
+            if (result != null)
+            {
+
+                var policy = new CacheItemPolicy
+                {
+                    AbsoluteExpiration = timeout == null ? ObjectCache.InfiniteAbsoluteExpiration : DateTime.Now.Add(timeout.Value),
+                    SlidingExpiration = TimeSpan.Zero
+                };
+
+                //TODO: CUrrently we cannot implement this in this provider, we'll have to change the underlying interface
+                // to accept an array of files instead of CacheDependency.
+                //policy.ChangeMonitors.Add(new HostFileChangeMonitor(cacheDependency.));
+
+                MemoryCache.Set(cacheKey, result, policy);
+            }
+        }
+        
+    }
+}

src/Umbraco.Core/Cache/RuntimeCacheProviderBase.cs

@@ -1,24 +0,0 @@
-using System;
-using System.Text;
-using System.Web.Caching;
-
-namespace Umbraco.Core.Cache
-{
-    /// <summary>
-    /// An abstract class for implementing a runtime cache provider
-    /// </summary>
-    /// <remarks>
-    /// THIS MUST REMAIN INTERNAL UNTIL WE STREAMLINE HOW ALL CACHE IS HANDLED, WE NEED TO SUPPORT HTTP RUNTIME CACHE, IN MEMORY CACHE, REQUEST CACHE, ETC...
-    /// </remarks>
-    internal abstract class RuntimeCacheProviderBase : CacheProviderBase
-    {
-        public abstract T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
-    }
-}

src/Umbraco.Core/Cache/StaticCacheProvider.cs

@@ -10,51 +10,72 @@ namespace Umbraco.Core.Cache
     /// <summary>
     /// A cache provider that statically caches everything in an in memory dictionary
     /// </summary>
-    internal class StaticCacheProvider : CacheProviderBase
+    internal class StaticCacheProvider : ICacheProvider
     {
-        private readonly ConcurrentDictionary<string, object> _staticCache = new ConcurrentDictionary<string, object>();
+        internal readonly ConcurrentDictionary<string, object> StaticCache = new ConcurrentDictionary<string, object>();
 
-        public override void ClearAllCache()
+        public virtual void ClearAllCache()
         {
-            _staticCache.Clear();
+            StaticCache.Clear();
         }
 
-        public override void ClearCacheItem(string key)
+        public virtual void ClearCacheItem(string key)
         {
             object val;
-            _staticCache.TryRemove(key, out val);
+            StaticCache.TryRemove(key, out val);
         }
 
-        public override void ClearCacheObjectTypes(string typeName)
+        public virtual void ClearCacheObjectTypes(string typeName)
         {
-            _staticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType().ToString().InvariantEquals(typeName));
+            foreach (var key in StaticCache.Keys)
+            {
+                if (StaticCache[key] != null
+                    && StaticCache[key].GetType().ToString().InvariantEquals(typeName))
+                {
+                    object val;
+                    StaticCache.TryRemove(key, out val);
+                }
+            }
         }
 
-        public override void ClearCacheObjectTypes<T>()
+        public virtual void ClearCacheObjectTypes<T>()
         {
-            var typeOfT = typeof (T);
-            _staticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType() == typeOfT);
+            foreach (var key in StaticCache.Keys)
+            {
+                if (StaticCache[key] != null
+                    && StaticCache[key].GetType() == typeof(T))
+                {
+                    object val;
+                    StaticCache.TryRemove(key, out val);
+                }
+            }
         }
 
-        public override void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
+        public virtual void ClearCacheByKeySearch(string keyStartsWith)
         {
-            var typeOfT = typeof(T);
-            _staticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType() == typeOfT && predicate(kvp.Key, (T)kvp.Value));
+            foreach (var key in StaticCache.Keys)
+            {
+                if (key.InvariantStartsWith(keyStartsWith))
+                {
+                    ClearCacheItem(key);
+                }
+            }
         }
 
-        public override void ClearCacheByKeySearch(string keyStartsWith)
+        public virtual void ClearCacheByKeyExpression(string regexString)
         {
-            _staticCache.RemoveAll(kvp => kvp.Key.InvariantStartsWith(keyStartsWith));
+            foreach (var key in StaticCache.Keys)
+            {
+                if (Regex.IsMatch(key, regexString))
+                {
+                    ClearCacheItem(key);
+                }
+            }
         }
 
-        public override void ClearCacheByKeyExpression(string regexString)
+        public virtual IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
         {
-            _staticCache.RemoveAll(kvp => Regex.IsMatch(kvp.Key, regexString));
-        }
-
-        public override IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
-        {
-            return (from KeyValuePair<string, object> c in _staticCache
+            return (from KeyValuePair<string, object> c in StaticCache
                     where c.Key.InvariantStartsWith(keyStartsWith)
                     select c.Value.TryConvertTo<T>()
                     into attempt
@@ -62,9 +83,9 @@ namespace Umbraco.Core.Cache
                     select attempt.Result).ToList();
         }
 
-        public override T GetCacheItem<T>(string cacheKey)
+        public virtual T GetCacheItem<T>(string cacheKey)
         {
-            var result = _staticCache[cacheKey];
+            var result = StaticCache[cacheKey];
             if (result == null)
             {
                 return default(T);
@@ -72,9 +93,9 @@ namespace Umbraco.Core.Cache
             return result.TryConvertTo<T>().Result;
         }
 
-        public override T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
+        public virtual T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
         {
-            return (T)_staticCache.GetOrAdd(cacheKey, key => getCacheItem());
+            return (T)StaticCache.GetOrAdd(cacheKey, getCacheItem());
         }
         
     }