/// <summary>
/// Changes the expiration <paramref name="mode" /> and <paramref name="timeout" /> for the
/// given <paramref name="key" />.
/// </summary>
/// <param name="key">The cache key.</param>
/// <param name="mode">The expiration mode.</param>
/// <param name="timeout">The expiration timeout.</param>
public override void Expire(string key, ExpirationMode mode, TimeSpan timeout)
{
this.CheckDisposed();
var item = this.GetCacheItem(key);
if (item == null)
{
this.Logger.LogTrace("Expire: item not found for key {0}", key);
return;
}
if (mode == ExpirationMode.Absolute)
{
item = item.WithAbsoluteExpiration(timeout);
}
else if (mode == ExpirationMode.Sliding)
{
item = item.WithSlidingExpiration(timeout);
}
else if (mode == ExpirationMode.None)
{
item = item.WithNoExpiration();
}
else if (mode == ExpirationMode.Default)
{
item = item.WithDefaultExpiration();
}
item = GetItemExpiration(item);
this.PutInternalPrepared(item);
}
public async Task ExpireAsync(string key, ExpirationMode mode, TimeSpan timeout)
{
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentNullException(nameof(key));
}
switch (mode)
{
case ExpirationMode.Absolute:
await _cache.KeyExpireAsync(key, DateTime.Now.AddSeconds(timeout.TotalSeconds));
break;
case ExpirationMode.Default:
await _cache.KeyExpireAsync(key, DateTime.Now.AddSeconds(timeout.TotalSeconds));
break;
case ExpirationMode.None:
await _cache.KeyExpireAsync(key, DateTime.Now.AddDays(365));
break;
case ExpirationMode.Sliding:
await _cache.KeyExpireAsync(key, timeout);
break;
}
}
public void Put(string key, TCacheValue value, ExpiredMode mode, TimeSpan timespan)
{
ExpirationMode expiretionMode = CacheUtility.ConvertFromCustomExpiredMode(mode);
CacheItem <TCacheValue> item = new CacheItem <TCacheValue>(key, value, expiretionMode, timespan);
cacheManger.Put(item);
}
private ICacheManager <T> GetCacheManager(string cacheName, ExpirationMode expirationMode, TimeSpan timeout)
{
lock (obj)
{
var cache = CacheFactory.Build <T>(cacheName,
settings =>
{
settings
.WithSystemRuntimeCacheHandle(instanceName)
.EnableStatistics()
.EnablePerformanceCounters()
.WithExpiration(expirationMode, timeout);
});
if (!cacheManagerDict.Keys.Contains(cacheName))
{
cacheManagerDict.Add(cacheName, cache);
return(cache);
}
else
{
return(cacheManagerDict[cacheName]);
}
}
}
public Task ExpireAsync <T>(string key, ExpirationMode expirationMode, TimeSpan timeout)
{
var cacheManager = GetCacheManager <T>();
cacheManager.Expire(key, _region, expirationMode, timeout);
return(Task.Run(() => { }));
}
public ExpirationCalculation(DateTimeOffset initail, TimeSpan slidingSize, DateTimeOffset maxExpireDate)
{
IsNegativeSlidingSize(slidingSize);
createDate = DateTimeOffset.Now;
this.slidingSize = slidingSize;
this.initail = initail;
this.maxExpireDate = maxExpireDate;
expireInfo = new Effective(initail);
mode = ExpirationMode.Sliding;
}
public ExpirationCalculation(DateTimeOffset initail)
{
maxCount = 0;
createDate = DateTime.Now;
slidingSize = TimeSpan.Zero;
this.initail = initail;
maxExpireDate = initail;
expireInfo = new Effective(initail);
mode = ExpirationMode.Absolute;
}
public void Expire(string key, string region, ExpirationMode expirationMode, TimeSpan timeout)
{
try
{
cacheManager.Expire(key, region, expirationMode, timeout);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Sets the expiration mode and timeout of the cache handle.
/// </summary>
/// <param name="expirationMode">The expiration mode.</param>
/// <param name="timeout">The timeout.</param>
/// <returns>The builder part.</returns>
/// <exception cref="System.InvalidOperationException">
/// If expiration mode is not set to 'None', timeout cannot be zero.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Thrown if expiration mode is not 'None' and timeout is zero.
/// </exception>
/// <seealso cref="ExpirationMode"/>
public ConfigurationBuilderCacheHandlePart WithExpiration(ExpirationMode expirationMode, TimeSpan timeout)
{
if (expirationMode != ExpirationMode.None && timeout == TimeSpan.Zero)
{
throw new InvalidOperationException("If expiration mode is not set to 'None', timeout cannot be zero.");
}
this.Configuration.ExpirationMode = expirationMode;
this.Configuration.ExpirationTimeout = timeout;
return(this);
}
public ExpirationCalculation(DateTimeOffset initail, TimeSpan slidingSize, uint maxCount = 0)
{
IsNegativeSlidingSize(slidingSize);
this.maxCount = maxCount;
createDate = DateTime.Now;
this.slidingSize = slidingSize;
this.initail = initail;
maxExpireDate = maxCount != 0 ? initail.Add(new TimeSpan(slidingSize.Ticks * maxCount)) : maxExpireDate;
expireInfo = new Effective(initail);
mode = ExpirationMode.Sliding;
}
/// <summary>
/// Sets the expiration mode and timeout of the cache handle.
/// </summary>
/// <param name="expirationMode">The expiration mode.</param>
/// <param name="timeout">The timeout.</param>
/// <returns>The builder part.</returns>
/// <exception cref="System.InvalidOperationException">
/// If expiration mode is not set to 'None', timeout cannot be zero.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Thrown if expiration mode is not 'None' and timeout is zero.
/// </exception>
/// <seealso cref="ExpirationMode"/>
public ConfigurationBuilderCacheHandlePart WithExpiration(ExpirationMode expirationMode, TimeSpan timeout)
{
// fixed #192 (was missing check for "Default" mode)
if (expirationMode != ExpirationMode.None && expirationMode != ExpirationMode.Default && timeout == TimeSpan.Zero)
{
throw new InvalidOperationException("If expiration mode is not set to 'None', timeout cannot be zero.");
}
Configuration.ExpirationMode = expirationMode;
Configuration.ExpirationTimeout = timeout;
return(this);
}
public void Add(string key, TValue value, ExpirationMode expiration, TimeSpan timeout)
{
Remove(key);
if (timeout != TimeSpan.Zero)
{
var cacheItem = new CacheItem <TValue>(key, value, expiration, timeout);
_cacheManager.Add(cacheItem);
}
else
{
_cacheManager.Add(key, value);
}
}
/// <summary>
/// Changes the expiration <paramref name="mode" /> and <paramref name="timeout" /> for the
/// given <paramref name="key" />.
/// </summary>
/// <param name="key">The cache key.</param>
/// <param name="region">The cache region.</param>
/// <param name="mode">The expiration mode.</param>
/// <param name="timeout">The expiration timeout.</param>
public override void Expire(string key, string region, ExpirationMode mode, TimeSpan timeout)
{
this.CheckDisposed();
var item = this.GetCacheItem(key, region);
if (item == null)
{
this.Logger.LogTrace("Expire: item not found for key {0}:{1}", key, region);
return;
}
this.PutInternalPrepared(item.WithExpiration(mode, timeout));
}
public static LazyCacheEntryOptions SetAbsoluteExpiration(this LazyCacheEntryOptions option, TimeSpan absoluteExpiration,
ExpirationMode mode)
{
if (option == null)
{
throw new ArgumentNullException(nameof(option));
}
option.AbsoluteExpirationRelativeToNow = absoluteExpiration;
option.ExpirationMode = mode;
option.ImmediateAbsoluteExpirationRelativeToNow = absoluteExpiration;
return(option);
}
public void CacheItem_Ctor3_NullValue()
{
// arrange
string key = "key";
object value = null;
ExpirationMode mode = 0;
TimeSpan timeout = default(TimeSpan);
// act
Action act = () => new CacheItem <object>(key, value, mode, timeout);
// assert
act.ShouldThrow <ArgumentException>().WithMessage("*cannot be null.\r\nParameter name: value");
}
public MemoryCacheImpl(string cacheName, ExpirationMode expirationMode, TimeSpan timeout)
{
if (MemoryCacheImpl <T> .cacheManagerDict != null)
{
if (cacheManagerDict.ContainsKey(cacheName))
{
cacheManager = cacheManagerDict[cacheName];
}
else
{
cacheManager = GetCacheManager(cacheName, expirationMode, timeout);
}
}
}
public void CacheItemValidation_Ctor3_EmptyKey()
{
// arrange
var key = string.Empty;
object value = null;
ExpirationMode mode = 0;
TimeSpan timeout = default(TimeSpan);
// act
Action act = () => new CacheItem <object>(key, value, mode, timeout);
// assert
act.Should().Throw <ArgumentException>().WithMessage("*Parameter name: key");
}
public void CacheItem_Ctor3_WhitespaceKey()
{
// arrange
string key = " ";
object value = null;
ExpirationMode mode = 0;
TimeSpan timeout = default(TimeSpan);
// act
Action act = () => new CacheItem <object>(key, value, mode, timeout);
// assert
act.ShouldThrow <ArgumentException>().WithMessage("*Parameter name: key");
}
public void CacheItem_Ctor4_EmptyKey()
{
// arrange
var key = string.Empty;
object value = null;
string region = null;
ExpirationMode mode = ExpirationMode.None;
TimeSpan timeout = default(TimeSpan);
// act
Action act = () => new CacheItem <object>(key, value, region, mode, timeout);
// assert
act.ShouldThrow <ArgumentException>().WithMessage("*cannot be null.\r\nParameter name: key");
}
public void Set <T>(string key, T value, ExpirationMode expirationMode, int expiration)
{
MemoryCacheEntryOptions options = new MemoryCacheEntryOptions();
TimeSpan expire = TimeSpan.FromSeconds(expiration);
if (expirationMode == ExpirationMode.Sliding)
{
options.SlidingExpiration = expire;
}
else
{
options.AbsoluteExpirationRelativeToNow = expire;
}
MemoryCache.Set(key, value, options);
}
public static LazyCacheEntryOptions SetAbsoluteExpiration(this LazyCacheEntryOptions option, DateTimeOffset absoluteExpiration,
ExpirationMode mode)
{
if (option == null)
{
throw new ArgumentNullException(nameof(option));
}
var delay = absoluteExpiration.Subtract(DateTimeOffset.UtcNow);
option.AbsoluteExpiration = absoluteExpiration;
option.ExpirationMode = mode;
option.ImmediateAbsoluteExpirationRelativeToNow = delay;
return(option);
}
public void CacheItem_Ctor4_NullValue()
{
// arrange
string key = "key";
object value = null;
string region = null;
ExpirationMode mode = ExpirationMode.None;
TimeSpan timeout = default(TimeSpan);
// act
Action act = () => new CacheItem <object>(key, region, value, mode, timeout);
// assert
act.ShouldThrow <ArgumentNullException>().WithMessage("*Parameter name: value");
}
public void CacheItem_Ctor4_WhitespaceRegion()
{
// arrange
string key = "key";
string value = "value";
string region = " ";
ExpirationMode mode = ExpirationMode.None;
TimeSpan timeout = default(TimeSpan);
// act
Action act = () => new CacheItem <object>(key, region, value, mode, timeout);
// assert
act.ShouldThrow <ArgumentException>()
.WithMessage("*Parameter name: region");
}
public static void EnableOutputCaching(this HttpContext context,
bool noCache,
int sharedTimeSpan,
int clientTimeSpan,
int serverTimeSpan,
bool excludeQueryStringFromCacheKey,
bool mustRevalidate,
bool anonymousOnly,
Type cacheKeyGenerator,
bool @private,
Type customTimeSpanMethodClassType,
string customTimeSpanMethodName,
bool cachePerUser,
ExpirationMode expirationMode,
string apiName,
bool logEnabled,
string actionName,
string controllerName)
{
var feature = context.Features.Get <ApiResponseCacheConfig>();
if (feature == null)
{
feature = new ApiResponseCacheConfig();
context.Features.Set(feature);
}
feature.AnonymousOnly = anonymousOnly;
feature.NoCache = noCache;
feature.SharedTimeSpan = sharedTimeSpan;
feature.ClientTimeSpan = clientTimeSpan;
feature.ServerTimeSpan = serverTimeSpan;
feature.ExcludeQueryStringFromCacheKey = excludeQueryStringFromCacheKey;
feature.MustRevalidate = mustRevalidate;
feature.CacheKeyGenerator = cacheKeyGenerator;
feature.Private = @private;
feature.CustomTimeSpanMethodClassType = customTimeSpanMethodClassType;
feature.CustomTimeSpanMethodName = customTimeSpanMethodName;
feature.CachePerUser = cachePerUser;
feature.ExpirationMode = expirationMode;
feature.ApiName = apiName;
feature.LogEnabled = logEnabled;
feature.ActionName = actionName;
feature.ControllerName = controllerName;
}
public static Task <T> GetOrAddAsync <T>(this IAppCache cache, string key, Func <Task <T> > addItemFactory,
DateTimeOffset expires, ExpirationMode mode)
{
if (cache == null)
{
throw new ArgumentNullException(nameof(cache));
}
switch (mode)
{
case ExpirationMode.LazyExpiration:
return(cache.GetOrAddAsync(key, addItemFactory, new MemoryCacheEntryOptions {
AbsoluteExpiration = expires
}));
default:
return(cache.GetOrAddAsync(key, addItemFactory, new LazyCacheEntryOptions().SetAbsoluteExpiration(expires, mode)));
}
}
public void CacheItem_Ctor3_ValidateCreatedResult()
{
// arrange
string key = "key";
object value = "value";
ExpirationMode mode = ExpirationMode.Sliding;
TimeSpan timeout = new TimeSpan(0, 23, 45);
// act
var act = new CacheItem <object>(key, value, mode, timeout);
// assert
act.Should()
.Match <CacheItem <object> >(p => p.ExpirationMode == mode)
.And.Match <CacheItem <object> >(p => p.ExpirationTimeout == timeout)
.And.Match <CacheItem <object> >(p => p.Key == key)
.And.Match <CacheItem <object> >(p => p.Value == value)
.And.Match <CacheItem <object> >(p => p.Region == null);
}
/// <inheritdoc />
public void Expire(TKey key, ExpirationMode mode, TimeSpan timeout)
{
CheckDisposed();
var item = GetCacheItemInternal(key);
if (item == null)
{
Logger.LogTrace($"Expire: item not found for key {key}");
return;
}
if (_logTrace)
{
Logger.LogTrace($"Expire [{item}] started.");
}
if (mode == ExpirationMode.Absolute)
{
item = item.WithAbsoluteExpiration(timeout);
}
else if (mode == ExpirationMode.Sliding)
{
item = item.WithSlidingExpiration(timeout);
}
else if (mode == ExpirationMode.None)
{
item = item.WithNoExpiration();
}
else if (mode == ExpirationMode.Default)
{
item = item.WithDefaultExpiration();
}
if (_logTrace)
{
Logger.LogTrace($"Expire - Expiration of [{item}] has been modified. Using put to store the item...");
}
PutInternal(item);
}
private void ExpireInternal(string key, string region, ExpirationMode mode, TimeSpan timeout)
{
CheckDisposed();
var item = GetCacheItemInternal(key, region);
if (item == null)
{
Logger.LogTrace("Expire: item not found for key {0}:{1}", key, region);
return;
}
if (_logTrace)
{
Logger.LogTrace("Expire [{0}] started.", item);
}
if (mode == ExpirationMode.Absolute)
{
item = item.WithAbsoluteExpiration(timeout);
}
else if (mode == ExpirationMode.Sliding)
{
item = item.WithSlidingExpiration(timeout);
}
else if (mode == ExpirationMode.None)
{
item = item.WithNoExpiration();
}
else if (mode == ExpirationMode.Default)
{
item = item.WithDefaultExpiration();
}
if (_logTrace)
{
Logger.LogTrace("Expire - Expiration of [{0}] has been modified. Using put to store the item...", item);
}
PutInternal(item);
}
public static async Task <T> GetOrAddAsync <T>(
this ICacheManager <T> cacheManager,
string key,
Func <string, Task <T> > valueFactory,
ExpirationMode expirationMode,
TimeSpan timeout)
{
T result;
if (cacheManager.Exists(key))
{
result = cacheManager.Get <T>(key);
}
else
{
result = await valueFactory(key).ConfigureAwait(false);
cacheManager.Add(new CacheItem <T>(key, result, expirationMode, timeout));
}
return(result);
}
/// <summary> /// Changes the expiration <paramref name="mode"/> and <paramref name="timeout"/> for the /// given <paramref name="key"/> in <paramref name="region"/>. /// </summary> /// <param name="key">The cache key.</param> /// <param name="region">The cache region.</param> /// <param name="mode">The expiration mode.</param> /// <param name="timeout">The expiration timeout.</param> public abstract void Expire(string key, string region, ExpirationMode mode, TimeSpan timeout);
/// <summary>
/// Sets the expiration mode and timeout of the cache handle.
/// </summary>
/// <param name="expirationMode">The expiration mode.</param>
/// <param name="timeout">The timeout.</param>
/// <returns>The builder part.</returns>
/// <exception cref="System.InvalidOperationException">
/// If expiration mode is not set to 'None', timeout cannot be zero.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Thrown if expiration mode is not 'None' and timeout is zero.
/// </exception>
/// <seealso cref="ExpirationMode"/>
public ConfigurationBuilderCacheHandlePart WithExpiration(ExpirationMode expirationMode, TimeSpan timeout)
{
if (expirationMode != ExpirationMode.None && timeout == TimeSpan.Zero)
{
throw new InvalidOperationException("If expiration mode is not set to 'None', timeout cannot be zero.");
}
this.Configuration.ExpirationMode = expirationMode;
this.Configuration.ExpirationTimeout = timeout;
return this;
}