/// <summary>
/// Invalidates all of the cache entries which are dependent on any of the specified root keys.
/// </summary>
/// <param name="cacheKey">Stores information of the computed key of the input LINQ query.</param>
public void InvalidateCacheDependencies(EFCacheKey cacheKey)
{
foreach (var rootCacheKey in cacheKey.CacheDependencies)
{
_readerWriterLockProvider.TryWriteLocked(() => _redisDbCache.RemoveByPattern(rootCacheKey));
}
}
/// <summary>
/// Invalidates all of the cache entries which are dependent on any of the specified root keys.
/// </summary>
/// <param name="cacheKey">Stores information of the computed key of the input LINQ query.</param>
public void InvalidateCacheDependencies(EFCacheKey cacheKey)
{
_readerWriterLockProvider.TryWriteLocked(() =>
{
foreach (var rootCacheKey in cacheKey.CacheDependencies)
{
if (string.IsNullOrWhiteSpace(rootCacheKey))
{
continue;
}
var cachedValue = _easyCachingProvider.Get <EFCachedData>(cacheKey.KeyHash);
var dependencyKeys = _easyCachingProvider.Get <HashSet <string> >(rootCacheKey);
if (areRootCacheKeysExpired(cachedValue, dependencyKeys))
{
_logger.LogDebug(CacheableEventId.QueryResultInvalidated,
$"Invalidated all of the cache entries due to early expiration of a root cache key[{rootCacheKey}].");
ClearAllCachedEntries();
return;
}
clearDependencyValues(dependencyKeys);
_easyCachingProvider.Remove(rootCacheKey);
}
});
}
/// <summary>
/// Adds a new item to the cache.
/// </summary>
/// <param name="cacheKey">key</param>
/// <param name="value">value</param>
/// <param name="cachePolicy">Defines the expiration mode of the cache item.</param>
public void InsertValue(EFCacheKey cacheKey, EFCachedData value, EFCachePolicy cachePolicy)
{
_readerWriterLockProvider.TryWriteLocked(() =>
{
if (value == null)
{
value = new EFCachedData {
IsNull = true
};
}
var keyHash = cacheKey.KeyHash;
foreach (var rootCacheKey in cacheKey.CacheDependencies)
{
var items = _easyCachingProvider.Get <HashSet <string> >(rootCacheKey);
if (items.IsNull)
{
_easyCachingProvider.Set(rootCacheKey, new HashSet <string> {
keyHash
}, cachePolicy.CacheTimeout);
}
else
{
items.Value.Add(keyHash);
_easyCachingProvider.Set(rootCacheKey, items.Value, cachePolicy.CacheTimeout);
}
}
// We don't support Sliding Expiration at this time. -> https://github.com/dotnetcore/EasyCaching/issues/113
_easyCachingProvider.Set(keyHash, value, cachePolicy.CacheTimeout);
});
}
/// <summary>
/// Invalidates all of the cache entries which are dependent on any of the specified root keys.
/// </summary>
/// <param name="cacheKey">Stores information of the computed key of the input LINQ query.</param>
public void InvalidateCacheDependencies(EFCacheKey cacheKey)
{
foreach (var rootCacheKey in cacheKey.CacheDependencies)
{
_readerWriterLockProvider.TryWriteLocked(() => _signal.RemoveChangeToken(rootCacheKey));
}
}
/// <summary>
/// Adds a new item to the cache.
/// </summary>
/// <param name="cacheKey">key</param>
/// <param name="value">value</param>
/// <param name="cachePolicy">Defines the expiration mode of the cache item.</param>
public void InsertValue(EFCacheKey cacheKey, EFCachedData value, EFCachePolicy cachePolicy)
{
_readerWriterLockProvider.TryWriteLocked(() =>
{
if (value == null)
{
value = new EFCachedData {
IsNull = true
};
}
var options = new MemoryCacheEntryOptions {
Size = 1
};
if (cachePolicy.CacheExpirationMode == CacheExpirationMode.Absolute)
{
options.AbsoluteExpirationRelativeToNow = cachePolicy.CacheTimeout;
}
else
{
options.SlidingExpiration = cachePolicy.CacheTimeout;
}
foreach (var rootCacheKey in cacheKey.CacheDependencies)
{
options.ExpirationTokens.Add(_signal.GetChangeToken(rootCacheKey));
}
_memoryCache.Set(cacheKey.KeyHash, value, options);
});
}
/// <summary>
/// Gets a cached entry by key.
/// </summary>
/// <param name="cacheKey">key to find</param>
/// <returns>cached value</returns>
/// <param name="cachePolicy">Defines the expiration mode of the cache item.</param>
public EFCachedData GetValue(EFCacheKey cacheKey, EFCachePolicy cachePolicy)
{
return(_readerWriterLockProvider.TryReadLocked(() =>
{
var returnValue = _easyCachingProvider.Get <EFCachedData>(cacheKey.KeyHash).Value;
return returnValue;
}));
}
/// <summary>
/// Invalidates all of the cache entries which are dependent on any of the specified root keys.
/// </summary>
/// <param name="cacheKey">Stores information of the computed key of the input LINQ query.</param>
public void InvalidateCacheDependencies(EFCacheKey cacheKey)
{
if (cacheKey == null)
{
throw new ArgumentNullException(nameof(cacheKey));
}
foreach (var rootCacheKey in cacheKey.CacheDependencies)
{
_readerWriterLockProvider.TryWriteLocked(() => _signal.RemoveChangeToken(rootCacheKey));
}
}
/// <summary>
/// Adds a new item to the cache.
/// </summary>
/// <param name="cacheKey">key</param>
/// <param name="value">value</param>
/// <param name="cachePolicy">Defines the expiration mode of the cache item.</param>
public void InsertValue(EFCacheKey cacheKey, EFCachedData value, EFCachePolicy cachePolicy)
{
_readerWriterLockProvider.TryWriteLocked(() =>
{
if (value == null)
{
value = new EFCachedData {
IsNull = true
};
}
_redisDbCache.Set(getKey(cacheKey), value, cachePolicy);
});
}
private static string getKey(EFCacheKey cacheKey)
{
if (cacheKey.CacheDependencies?.Any() != true)
{
throw new NullReferenceException(nameof(cacheKey.CacheDependencies));
}
if (string.IsNullOrWhiteSpace(cacheKey.KeyHash))
{
throw new NullReferenceException(nameof(cacheKey.KeyHash));
}
return($"{string.Join("_", cacheKey.CacheDependencies)}_{cacheKey.KeyHash}");
}
/// <summary>
/// Invalidates all of the cache entries which are dependent on any of the specified root keys.
/// </summary>
/// <param name="cacheKey">Stores information of the computed key of the input LINQ query.</param>
public void InvalidateCacheDependencies(EFCacheKey cacheKey)
{
_readerWriterLockProvider.TryWriteLocked(() =>
{
foreach (var rootCacheKey in cacheKey.CacheDependencies)
{
if (string.IsNullOrWhiteSpace(rootCacheKey))
{
continue;
}
clearDependencyValues(rootCacheKey);
_easyCachingProvider.Remove(rootCacheKey);
}
});
}
/// <summary>
/// Adds a new item to the cache.
/// </summary>
/// <param name="cacheKey">key</param>
/// <param name="value">value</param>
/// <param name="cachePolicy">Defines the expiration mode of the cache item.</param>
public void InsertValue(EFCacheKey cacheKey, EFCachedData value, EFCachePolicy cachePolicy)
{
_readerWriterLockProvider.TryWriteLocked(() =>
{
if (value == null)
{
value = new EFCachedData {
IsNull = true
};
}
var keyHash = cacheKey.KeyHash;
foreach (var rootCacheKey in cacheKey.CacheDependencies)
{
_dependenciesCacheManager.AddOrUpdate(
rootCacheKey,
new HashSet <string>(StringComparer.OrdinalIgnoreCase)
{
keyHash
},
updateValue: set =>
{
set.Add(keyHash);
return(set);
});
}
if (cachePolicy == null)
{
_valuesCacheManager.Add(keyHash, value);
}
else
{
_valuesCacheManager.Add(new CacheItem <EFCachedData>(
keyHash,
value,
cachePolicy.CacheExpirationMode == CacheExpirationMode.Absolute ? ExpirationMode.Absolute : ExpirationMode.Sliding,
cachePolicy.CacheTimeout));
}
});
}
/// <summary>
/// Invalidates all of the cache entries which are dependent on any of the specified root keys.
/// </summary>
public bool InvalidateCacheDependencies(string commandText, EFCacheKey cacheKey)
{
if (cacheKey is null)
{
throw new ArgumentNullException(nameof(cacheKey));
}
if (!_sqlCommandsProcessor.IsCrudCommand(commandText))
{
_logger.LogDebug($"Skipped invalidating a none-CRUD command[{commandText}].");
return(false);
}
if (shouldSkipCacheInvalidationCommands(commandText))
{
_logger.LogDebug($"Skipped invalidating the related cache entries of this query[{commandText}] based on the provided predicate.");
return(false);
}
cacheKey.CacheDependencies.Add($"{_cacheKeyPrefix}{EFCachePolicy.UnknownsCacheDependency}");
_cacheServiceProvider.InvalidateCacheDependencies(cacheKey);
_logger.LogDebug(CacheableEventId.QueryResultInvalidated, $"Invalidated [{string.Join(", ", cacheKey.CacheDependencies)}] dependencies.");
return(true);
}
/// <summary>
/// Gets a cached entry by key.
/// </summary>
/// <param name="cacheKey">key to find</param>
/// <returns>cached value</returns>
/// <param name="cachePolicy">Defines the expiration mode of the cache item.</param>
public EFCachedData GetValue(EFCacheKey cacheKey, EFCachePolicy cachePolicy)
{
return(_readerWriterLockProvider.TryReadLocked(() => _redisDbCache.Get <EFCachedData>(getKey(cacheKey), cachePolicy)));
}
/// <summary>
/// Gets a cached entry by key.
/// </summary>
/// <param name="cacheKey">key to find</param>
/// <returns>cached value</returns>
/// <param name="cachePolicy">Defines the expiration mode of the cache item.</param>
public EFCachedData GetValue(EFCacheKey cacheKey, EFCachePolicy cachePolicy)
{
return(_readerWriterLockProvider.TryReadLocked(() => _valuesCacheManager.Get <EFCachedData>(cacheKey.KeyHash)));
}