yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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.

Browse Source 
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
This commit is contained in:
Shannon
2013-12-16 12:51:02 +11:00
parent 9105c08a4c
commit f11d4fbedd
21 changed files with 1012 additions and 344 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/Umbraco.Core/Cache/CacheProviderBase.cs
View File

@@ -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);
}
}

178
src/Umbraco.Core/Cache/DictionaryCacheProdiverBase.cs Normal file
View File

@@ -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);
}
}
}

45
src/Umbraco.Core/Cache/DictionaryCacheWrapper.cs Normal file
View File

@@ -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();
}
}
}

14
src/Umbraco.Core/Cache/DictionaryItemWrapper.cs Normal file
View File

@@ -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; }
}
}

50
src/Umbraco.Core/Cache/HttpRequestCacheProvider.cs Normal file
View File

@@ -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];
}
}
}

177
src/Umbraco.Core/Cache/HttpRuntimeCacheProvider.cs
View File

@@ -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),

24
src/Umbraco.Core/Cache/ICacheProvider.cs Normal file
View File

@@ -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);
}
}

24
src/Umbraco.Core/Cache/IRuntimeCacheProvider.cs Normal file
View File

@@ -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);
}
}

34
src/Umbraco.Core/Cache/NullCacheProvider.cs
View File

@@ -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)
{
}
}

198
src/Umbraco.Core/Cache/ObjectCacheRuntimeCacheProvider.cs Normal file
View File

@@ -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);
}
}
}
}

24
src/Umbraco.Core/Cache/RuntimeCacheProviderBase.cs
View File

@@ -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);
}
}

75
src/Umbraco.Core/Cache/StaticCacheProvider.cs
View File

@@ -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());
}
}

172
src/Umbraco.Core/CacheHelper.cs
View File

@@ -18,10 +18,12 @@ namespace Umbraco.Core
public class CacheHelper
{
private readonly bool _enableCache;
private readonly CacheProviderBase _staticCache;
private readonly CacheProviderBase _nullStaticCache = new NullCacheProvider();
private readonly RuntimeCacheProviderBase _httpCache;
private readonly RuntimeCacheProviderBase _nullHttpCache = new NullCacheProvider();
private readonly ICacheProvider _requestCache;
private readonly ICacheProvider _nullRequestCache = new NullCacheProvider();
private readonly ICacheProvider _staticCache;
private readonly ICacheProvider _nullStaticCache = new NullCacheProvider();
private readonly IRuntimeCacheProvider _httpCache;
private readonly IRuntimeCacheProvider _nullHttpCache = new NullCacheProvider();
public CacheHelper(System.Web.Caching.Cache cache)
: this(cache, true)
@@ -33,18 +35,171 @@ namespace Umbraco.Core
{
}
internal CacheHelper(RuntimeCacheProviderBase httpCacheProvider, bool enableCache)
: this(httpCacheProvider, new StaticCacheProvider(), enableCache)
internal CacheHelper(IRuntimeCacheProvider httpCacheProvider, bool enableCache)
: this(httpCacheProvider, new StaticCacheProvider(), new HttpRequestCacheProvider(HttpContext.Current), enableCache)
{
}
internal CacheHelper(RuntimeCacheProviderBase httpCacheProvider, CacheProviderBase staticCacheProvider, bool enableCache)
internal CacheHelper(
IRuntimeCacheProvider httpCacheProvider,
ICacheProvider staticCacheProvider,
ICacheProvider requestCacheProvider,
bool enableCache)
{
_httpCache = httpCacheProvider;
_staticCache = staticCacheProvider;
_enableCache = enableCache;
_requestCache = requestCacheProvider;
}
#region Request cache
/// <summary>
/// Clears the item in umbraco's request cache
/// </summary>
internal void ClearAllRequestCache()
{
if (!_enableCache)
{
_nullRequestCache.ClearAllCache();
}
else
{
_requestCache.ClearAllCache();
}
}
/// <summary>
/// Clears the item in umbraco's request cache with the given key
/// </summary>
/// <param name="key">Key</param>
internal void ClearRequestCacheItem(string key)
{
if (!_enableCache)
{
_nullRequestCache.ClearCacheItem(key);
}
else
{
_requestCache.ClearCacheItem(key);
}
}
/// <summary>
/// Clears all objects in the request 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>
internal void ClearRequestCacheObjectTypes(string typeName)
{
if (!_enableCache)
{
_nullRequestCache.ClearCacheObjectTypes(typeName);
}
else
{
_requestCache.ClearCacheObjectTypes(typeName);
}
}
/// <summary>
/// Clears all objects in the request cache with the System.Type specified
/// </summary>
internal void ClearRequestCacheObjectTypes<T>()
{
if (!_enableCache)
{
_nullRequestCache.ClearCacheObjectTypes<T>();
}
else
{
_requestCache.ClearCacheObjectTypes<T>();
}
}
/// <summary>
/// Clears all request cache items that starts with the key passed.
/// </summary>
/// <param name="keyStartsWith">The start of the key</param>
internal void ClearRequestCacheByKeySearch(string keyStartsWith)
{
if (!_enableCache)
{
_nullRequestCache.ClearCacheByKeySearch(keyStartsWith);
}
else
{
_requestCache.ClearCacheByKeySearch(keyStartsWith);
}
}
/// <summary>
/// Clears all cache items that have a key that matches the regular expression
/// </summary>
/// <param name="regexString"></param>
internal void ClearRequestCacheByKeyExpression(string regexString)
{
if (!_enableCache)
{
_nullRequestCache.ClearCacheByKeyExpression(regexString);
}
else
{
_requestCache.ClearCacheByKeyExpression(regexString);
}
}
internal IEnumerable<T> GetRequestCacheItemsByKeySearch<T>(string keyStartsWith)
{
if (!_enableCache)
{
return _nullRequestCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
}
else
{
return _requestCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
}
}
/// <summary>
/// Returns a request 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>
internal TT GetRequestCacheItem<TT>(string cacheKey)
{
if (!_enableCache)
{
return _nullRequestCache.GetCacheItem<TT>(cacheKey);
}
else
{
return _requestCache.GetCacheItem<TT>(cacheKey);
}
}
/// <summary>
/// Gets (and adds if necessary) an item from the request cache with all of the default parameters
/// </summary>
/// <typeparam name="TT"></typeparam>
/// <param name="cacheKey"></param>
/// <param name="getCacheItem"></param>
/// <returns></returns>
internal TT GetRequestCacheItem<TT>(string cacheKey, Func<TT> getCacheItem)
{
if (!_enableCache)
{
return _nullRequestCache.GetCacheItem<TT>(cacheKey, getCacheItem);
}
else
{
return _requestCache.GetCacheItem<TT>(cacheKey, getCacheItem);
}
}
#endregion
#region Static cache
/// <summary>
@@ -200,8 +355,7 @@ namespace Umbraco.Core
}
#endregion
#region Runtime/Http Cache
/// <summary>
/// Clears the item in umbraco's runtime cache

9
src/Umbraco.Core/Umbraco.Core.csproj
View File

@@ -113,10 +113,15 @@
<Compile Include="Auditing\IAuditWriteProvider.cs" />
<Compile Include="CacheHelper.cs" />
<Compile Include="Cache\CacheKeys.cs" />
<Compile Include="Cache\CacheProviderBase.cs" />
<Compile Include="Cache\ICacheProvider.cs" />
<Compile Include="Cache\CacheRefresherBase.cs" />
<Compile Include="Cache\CacheRefresherEventArgs.cs" />
<Compile Include="Cache\RuntimeCacheProviderBase.cs" />
<Compile Include="Cache\DictionaryCacheProdiverBase.cs" />
<Compile Include="Cache\DictionaryCacheWrapper.cs" />
<Compile Include="Cache\DictionaryItemWrapper.cs" />
<Compile Include="Cache\HttpRequestCacheProvider.cs" />
<Compile Include="Cache\ObjectCacheRuntimeCacheProvider.cs" />
<Compile Include="Cache\IRuntimeCacheProvider.cs" />
<Compile Include="Cache\HttpRuntimeCacheProvider.cs" />
<Compile Include="Cache\IJsonCacheRefresher.cs" />
<Compile Include="Cache\JsonCacheRefresherBase.cs" />

86
src/Umbraco.Tests/Cache/CacheHelperTests.cs
View File

@@ -1,86 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Web;
using System.Web.Caching;
using System.Web.UI;
using NUnit.Framework;
using Umbraco.Core;
using umbraco;
namespace Umbraco.Tests.Cache
{
[TestFixture]
public class CacheHelperTests
{
private CacheHelper _helper;
[SetUp]
public void Setup()
{
_helper = new CacheHelper(HttpRuntime.Cache);
}
[TearDown]
public void TearDown()
{
_helper.ClearAllCache();
}
[Test]
public void Can_Remove_By_Type_Name()
{
var cacheContent1 = new MacroCacheContent(new LiteralControl(), "Test1");
var cacheContent2 = new MacroCacheContent(new LiteralControl(), "Test2");
var cacheContent3 = new MacroCacheContent(new LiteralControl(), "Test3");
var cacheContent4 = new MacroCacheContent(new LiteralControl(), "Test4");
_helper.InsertCacheItem("Test1", CacheItemPriority.Default, new TimeSpan(0, 0, 60), () => cacheContent1);
_helper.InsertCacheItem("Test2", CacheItemPriority.Default, new TimeSpan(0, 0, 60), () => cacheContent2);
_helper.InsertCacheItem("Test3", CacheItemPriority.Default, new TimeSpan(0, 0, 60), () => cacheContent3);
_helper.InsertCacheItem("Test4", CacheItemPriority.Default, new TimeSpan(0, 0, 60), () => cacheContent4);
Assert.AreEqual(4, HttpRuntime.Cache.Count);
_helper.ClearCacheObjectTypes("umbraco.MacroCacheContent");
Assert.AreEqual(0, HttpRuntime.Cache.Count);
}
[Test]
public void Can_Remove_By_Strong_Type()
{
var cacheContent1 = new MacroCacheContent(new LiteralControl(), "Test1");
var cacheContent2 = new MacroCacheContent(new LiteralControl(), "Test2");
var cacheContent3 = new MacroCacheContent(new LiteralControl(), "Test3");
var cacheContent4 = new MacroCacheContent(new LiteralControl(), "Test4");
_helper.InsertCacheItem("Test1", CacheItemPriority.Default, new TimeSpan(0, 0, 60), () => cacheContent1);
_helper.InsertCacheItem("Test2", CacheItemPriority.Default, new TimeSpan(0, 0, 60), () => cacheContent2);
_helper.InsertCacheItem("Test3", CacheItemPriority.Default, new TimeSpan(0, 0, 60), () => cacheContent3);
_helper.InsertCacheItem("Test4", CacheItemPriority.Default, new TimeSpan(0, 0, 60), () => cacheContent4);
Assert.AreEqual(4, HttpRuntime.Cache.Count);
_helper.ClearCacheObjectTypes<MacroCacheContent>();
Assert.AreEqual(0, HttpRuntime.Cache.Count);
}
[Test]
public void Can_Add_Remove_Struct_Strongly_Typed_With_Null()
{
var now = DateTime.Now;
_helper.InsertCacheItem("DateTimeTest", CacheItemPriority.Default, new TimeSpan(0, 0, 0, 0, 200), () => now);
Assert.AreEqual(now, _helper.GetCacheItem<DateTime>("DateTimeTest"));
Assert.AreEqual(now, _helper.GetCacheItem<DateTime?>("DateTimeTest"));
Thread.Sleep(300); //sleep longer than the cache expiration
Assert.AreEqual(default(DateTime), _helper.GetCacheItem<DateTime>("DateTimeTest"));
Assert.AreEqual(null, _helper.GetCacheItem<DateTime?>("DateTimeTest"));
}
}
}

63
src/Umbraco.Tests/Cache/CacheProviderTests.cs Normal file
View File

@@ -0,0 +1,63 @@
using System.Web.UI;
using NUnit.Framework;
using Umbraco.Core.Cache;
using umbraco;
namespace Umbraco.Tests.Cache
{
public abstract class CacheProviderTests
{
internal abstract ICacheProvider Provider { get; }
protected abstract int GetTotalItemCount { get; }
[SetUp]
public virtual void Setup()
{
}
[TearDown]
public virtual void TearDown()
{
Provider.ClearAllCache();
}
[Test]
public void Can_Remove_By_Type_Name()
{
var cacheContent1 = new MacroCacheContent(new LiteralControl(), "Test1");
var cacheContent2 = new MacroCacheContent(new LiteralControl(), "Test2");
var cacheContent3 = new MacroCacheContent(new LiteralControl(), "Test3");
var cacheContent4 = new MacroCacheContent(new LiteralControl(), "Test4");
Provider.GetCacheItem("Test1", () => cacheContent1);
Provider.GetCacheItem("Test2", () => cacheContent2);
Provider.GetCacheItem("Test3", () => cacheContent3);
Provider.GetCacheItem("Test4", () => cacheContent4);
Assert.AreEqual(4, GetTotalItemCount);
Provider.ClearCacheObjectTypes("umbraco.MacroCacheContent");
Assert.AreEqual(0, GetTotalItemCount);
}
[Test]
public void Can_Remove_By_Strong_Type()
{
var cacheContent1 = new MacroCacheContent(new LiteralControl(), "Test1");
var cacheContent2 = new MacroCacheContent(new LiteralControl(), "Test2");
var cacheContent3 = new MacroCacheContent(new LiteralControl(), "Test3");
var cacheContent4 = new MacroCacheContent(new LiteralControl(), "Test4");
Provider.GetCacheItem("Test1", () => cacheContent1);
Provider.GetCacheItem("Test2", () => cacheContent2);
Provider.GetCacheItem("Test3", () => cacheContent3);
Provider.GetCacheItem("Test4", () => cacheContent4);
Assert.AreEqual(4, GetTotalItemCount);
Provider.ClearCacheObjectTypes<MacroCacheContent>();
Assert.AreEqual(0, GetTotalItemCount);
}
}
}

52
src/Umbraco.Tests/Cache/HttpRequestCacheProviderTests.cs Normal file
View File

@@ -0,0 +1,52 @@
using NUnit.Framework;
using Umbraco.Core.Cache;
using Umbraco.Tests.TestHelpers;
namespace Umbraco.Tests.Cache
{
[TestFixture]
public class HttpRequestCacheProviderTests : CacheProviderTests
{
private HttpRequestCacheProvider _provider;
private FakeHttpContextFactory _ctx;
public override void Setup()
{
base.Setup();
_ctx = new FakeHttpContextFactory("http://localhost/test");
_provider = new HttpRequestCacheProvider(() => _ctx.HttpContext);
}
internal override ICacheProvider Provider
{
get { return _provider; }
}
protected override int GetTotalItemCount
{
get { return _ctx.HttpContext.Items.Count; }
}
}
[TestFixture]
public class StaticCacheProviderTests : CacheProviderTests
{
private StaticCacheProvider _provider;
public override void Setup()
{
base.Setup();
_provider = new StaticCacheProvider();
}
internal override ICacheProvider Provider
{
get { return _provider; }
}
protected override int GetTotalItemCount
{
get { return _provider.StaticCache.Count; }
}
}
}

33
src/Umbraco.Tests/Cache/HttpRuntimeCacheProviderTests.cs Normal file
View File

@@ -0,0 +1,33 @@
using System.Web;
using NUnit.Framework;
using Umbraco.Core.Cache;
namespace Umbraco.Tests.Cache
{
[TestFixture]
public class HttpRuntimeCacheProviderTests : RuntimeCacheProviderTests
{
private HttpRuntimeCacheProvider _provider;
protected override int GetTotalItemCount
{
get { return HttpRuntime.Cache.Count; }
}
public override void Setup()
{
base.Setup();
_provider = new HttpRuntimeCacheProvider(HttpRuntime.Cache);
}
internal override ICacheProvider Provider
{
get { return _provider; }
}
internal override IRuntimeCacheProvider RuntimeProvider
{
get { return _provider; }
}
}
}

36
src/Umbraco.Tests/Cache/ObjectCacheProviderTests.cs Normal file
View File

@@ -0,0 +1,36 @@
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Umbraco.Core;
using Umbraco.Core.Cache;
namespace Umbraco.Tests.Cache
{
[TestFixture]
public class ObjectCacheProviderTests : RuntimeCacheProviderTests
{
private ObjectCacheRuntimeCacheProvider _provider;
protected override int GetTotalItemCount
{
get { return _provider.MemoryCache.Count(); }
}
public override void Setup()
{
base.Setup();
_provider = new ObjectCacheRuntimeCacheProvider();
}
internal override ICacheProvider Provider
{
get { return _provider; }
}
internal override IRuntimeCacheProvider RuntimeProvider
{
get { return _provider; }
}
}
}

30
src/Umbraco.Tests/Cache/RuntimeCacheProviderTests.cs Normal file
View File

@@ -0,0 +1,30 @@
using System;
using System.Threading;
using System.Web.Caching;
using NUnit.Framework;
using Umbraco.Core.Cache;
namespace Umbraco.Tests.Cache
{
public abstract class RuntimeCacheProviderTests : CacheProviderTests
{
internal abstract IRuntimeCacheProvider RuntimeProvider { get; }
[Test]
public void Can_Add_And_Expire_Struct_Strongly_Typed_With_Null()
{
var now = DateTime.Now;
RuntimeProvider.InsertCacheItem("DateTimeTest", CacheItemPriority.Default, new TimeSpan(0, 0, 0, 0, 200), () => now);
Assert.AreEqual(now, Provider.GetCacheItem<DateTime>("DateTimeTest"));
Assert.AreEqual(now, Provider.GetCacheItem<DateTime?>("DateTimeTest"));
Thread.Sleep(300); //sleep longer than the cache expiration
Assert.AreEqual(default(DateTime), Provider.GetCacheItem<DateTime>("DateTimeTest"));
Assert.AreEqual(null, Provider.GetCacheItem<DateTime?>("DateTimeTest"));
}
}
}

7
src/Umbraco.Tests/Umbraco.Tests.csproj
View File

@@ -101,6 +101,7 @@
<Reference Include="System.Net.Http.WebRequest, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\Microsoft.Net.Http.2.0.20710.0\lib\net40\System.Net.Http.WebRequest.dll</HintPath>
</Reference>
<Reference Include="System.Runtime.Caching" />
<Reference Include="System.Runtime.Serialization" />
<Reference Include="System.Web" />
<Reference Include="System.Web.ApplicationServices" />
@@ -151,7 +152,11 @@
<Compile Include="Persistence\Auditing\AuditTests.cs" />
<Compile Include="BootManagers\CoreBootManagerTests.cs" />
<Compile Include="BusinessLogic\DictionaryTest.cs" />
<Compile Include="Cache\CacheHelperTests.cs" />
<Compile Include="Cache\ObjectCacheProviderTests.cs" />
<Compile Include="Cache\CacheProviderTests.cs" />
<Compile Include="Cache\HttpRequestCacheProviderTests.cs" />
<Compile Include="Cache\HttpRuntimeCacheProviderTests.cs" />
<Compile Include="Cache\RuntimeCacheProviderTests.cs" />
<Compile Include="CodeFirst\Attributes\AliasAttribute.cs" />
<Compile Include="CodeFirst\Attributes\ContentTypeAttribute.cs" />
<Compile Include="CodeFirst\Attributes\DescriptionAttribute.cs" />