public ObjectCacheWrapper(CacheIdentity id = null,
Func <string, object, CacheItemPolicy> cacheItemPolicySelector = null)
: this(
new MemoryCache(id != null ? id.Name : CreateUniqueCacheName()),
instanceName : (id != null ? id.InstanceName : null),
cacheItemPolicySelector : cacheItemPolicySelector)
{
}
protected CacheBase(CacheIdentity id)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
Id = id;
PartionKeyPrefix = String.Format("{0}:", Id);
}
/// <summary>
/// Creates an instance from a pre-existing <see cref="ConcurrentDictionary{TKey,TValue}"/>
/// </summary>
public SimpleInmemoryCache(ConcurrentDictionary <string, object> cache, CacheIdentity id = null)
: base(id ?? CreateUniqueCacheName())
{
if (cache == null)
{
throw new ArgumentNullException("cache");
}
_inmemoryCache = cache;
}
private bool SetIsPaused(CacheIdentity cacheId, bool isPaused)
{
IPausableCache cache = PausableCaches.SingleOrDefault(c => c.Id == cacheId);
if (cache == null)
{
return(false);
}
cache.IsPaused = isPaused;
return(true);
}
/// <summary>
/// Deletes the item from the cache identified by it's <see cref="ICache.Id" />
/// </summary>
/// <param name="cacheId">The unique id of the cache to remove item from </param>
/// <param name="key">The key associated with the cached item to be removed</param>
/// <returns>True if a cache was found matching the id supplied</returns>
/// <remarks>
/// <c>true</c> will be returned even if the item was not in the cache
/// </remarks>
/// <exception cref="ArgumentException">Cache is paused</exception>
public bool RemoveItem(CacheIdentity cacheId, string key)
{
ICache cache = AllCaches.SingleOrDefault(c => c.Id == cacheId);
if (cache == null)
{
return(false);
}
if (cache.As <IPausableCache>() != null && cache.As <IPausableCache>().IsPaused)
{
throw new ArgumentException(string.Format("Cannot remove item from paused cache ('{0}')", cacheId));
}
cache.Remove(key);
return(true);
}
public virtual ICache Get <T>(CacheIdentity cacheId) where T : class
{
if (!_cacheConstructors.ContainsKey(typeof(T)))
{
throw new ArgumentException(string.Format(ExMsg, typeof(T).FullName));
}
if (cacheId == null)
{
throw new ArgumentNullException("cacheId");
}
ICache cache = _caches.GetOrAdd(cacheId.ToString(),
id => {
Func <CacheIdentity, ICache> ctor = _cacheConstructors[typeof(T)];
ICache c = ctor(id);
if (CacheAdministator != null)
{
return(CacheAdministator.Register(c));
}
return(c);
});
return(cache);
}
public SimpleInmemoryCache(CacheIdentity id = null) : this(new ConcurrentDictionary <string, object>(), id)
{
}
/// <summary>
/// Pauses the cache
/// </summary>
/// <param name="cacheId">The unique id of the instance to pause</param>
/// <returns>
/// True if a <em>pausable</em> cache was found matching the name supplied
/// </returns>
/// <remarks>
/// <c>true</c> will be returned even if the cache is already paused
/// </remarks>
public virtual bool PauseCache(CacheIdentity cacheId)
{
return(SetIsPaused(cacheId, true));
}
/// <summary>
/// Starts the cache
/// </summary>
/// <param name="cacheId">The unique id of the instance to start</param>
/// <returns>
/// True if a <em>pausable</em> cache was found matching the name supplied
/// </returns>
/// <remarks>
/// <c>true</c> will be returned even if the cache is already started
/// </remarks>
public virtual bool StartCache(CacheIdentity cacheId)
{
return(SetIsPaused(cacheId, false));
}
