public override void RegisterParentDependencyDefinition(string parentKey, CacheDependencyAction actionToPerform = CacheDependencyAction.ClearDependentItems)
{
Logger.WriteInfoMessage(string.Format("Registering parent item:[{0}]", parentKey));
var cacheKeyForParent = GetParentItemCacheKey(parentKey);
var item = new DependencyItem {
CacheKey = parentKey, Action = actionToPerform, IsParentNode = true
};
var depList = new DependencyItem[] { item };
Cache.InvalidateCacheItem(cacheKeyForParent);
Cache.Add(cacheKeyForParent, GetMaxAge(), depList);
}
public bool RegisterParentDefinition(string parentKey, CacheDependencyAction actionToPerform = CacheDependencyAction.ClearDependentItems)
{
Logger.WriteInfoMessage($"Registering parent item:[{parentKey}]");
var item = new DependencyItem {
CacheKey = parentKey, Action = actionToPerform, IsParentNode = true
};
var cacheValueItems = new List <RedisValue>();
var parentKeyExists = _redisDatabase.KeyExists(parentKey);
if (parentKeyExists)
{
Logger.WriteInfoMessage($"Registering parent item:[{parentKey}] - key already exists");
var currentValueType = _redisDatabase.KeyType(parentKey);
if (currentValueType == RedisType.String)
{
// it is NOT currently a List, which means it has a simple value and is not associated as a parent key at this time
// so we need to convert it
var currentKeyValue = _redisDatabase.StringGet(parentKey);
Cache.InvalidateCacheItem(parentKey);
cacheValueItems.Add(currentKeyValue.HasValue ? currentKeyValue : RedisValue.EmptyString);
cacheValueItems.Add(item.Serialize());
Logger.WriteInfoMessage($"Registering parent item:[{parentKey}] - regular cache item converted to parent key list");
}
else
{
Logger.WriteInfoMessage($"Registering parent item:[{parentKey}] - skipping registration, already registered");
return(false);
}
}
else
{
// Nothing exists thus far so we create the parent key as a list with the 1st item in the list
// as empty as the 1st item in a list for a parent key is always reserved for the cache key value of the parent key
// The dependent keys are in the list after that
cacheValueItems.Add(string.Empty);
Logger.WriteInfoMessage($"Registered parent item:[{parentKey}]");
}
if (cacheValueItems.Count > 0)
{
_redisDatabase.ListRightPush(parentKey, cacheValueItems.ToArray());
}
return(true);
}
public abstract void RegisterParentDependencyDefinition(string parentKey, CacheDependencyAction actionToPerform = CacheDependencyAction.ClearDependentItems);
public override void AssociateDependentKeysToParent(string parentKey, IEnumerable <string> dependentCacheKeys, CacheDependencyAction actionToPerform = CacheDependencyAction.ClearDependentItems)
{
Logger.WriteInfoMessage(string.Format("Associating list of cache keys to parent key:[{0}]", parentKey));
if (dependentCacheKeys == null)
{
return;
}
RegisterParentDependencyDefinition(parentKey, actionToPerform);
var depList = new List <DependencyItem>();
foreach (var dependentKey in dependentCacheKeys)
{
var item = new DependencyItem {
CacheKey = dependentKey, Action = actionToPerform, IsParentNode = false
};
depList.Add(item);
}
if (depList.Count > 0)
{
var redisList = depList.Select(r => (RedisValue)r.Serialize());
_redisDatabase.ListRightPush(parentKey, redisList.ToArray());
}
}
private T GetAndAddIfNecessary <T>(string cacheKey, Action <T> addData, Func <T> getData, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems) where T : class
{
if (!_config.IsCacheEnabled)
{
return(getData());
}
//Get data from cache
T data = _cache.Get <T>(cacheKey);
// check to see if we need to get data from the source
if (data == null)
{
//get data from source
data = getData();
//only add non null data to the cache.
if (data != null)
{
addData(data);
ManageCacheDependenciesForCacheItem(data, cacheKey, parentKey, actionForDependency);
}
}
else
{
_logger.WriteInfoMessage(string.Format("Retrieving item [{0}] from cache.", cacheKey));
}
return(data);
}
public T Get <T>(string cacheKey, TimeSpan slidingExpiryWindow, Func <T> getData, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems) where T : class
{
return(GetAndAddIfNecessary(cacheKey,
data =>
{
_cache.Add(cacheKey, slidingExpiryWindow, data);
_logger.WriteInfoMessage(
string.Format("Adding item [{0}] to cache with sliding sliding expiry window in seconds [{1}].", cacheKey,
slidingExpiryWindow.TotalSeconds));
},
getData,
parentKey,
actionForDependency
));
}
public T Get <T>(string cacheKey, DateTime expiryDate, Func <T> getData, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems) where T : class
{
return(GetAndAddIfNecessary(cacheKey,
data =>
{
_cache.Add(cacheKey, expiryDate, data);
_logger.WriteInfoMessage(string.Format("Adding item [{0}] to cache with expiry date/time of [{1}].", cacheKey,
expiryDate.ToString("dd/MM/yyyy hh:mm:ss")));
},
getData,
parentKey,
actionForDependency
));
}
public Task <T> GetAsync <T>(TimeSpan slidingExpiryWindow, Func <Task <T> > getData, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems) where T : class
{
return(GetAsync <T>(getData.GetCacheKey(), slidingExpiryWindow, getData, parentKey, actionForDependency));
}
private void ManageCacheDependenciesForCacheItem(object dataToAdd, string cacheKey, string parentKey, CacheDependencyAction action)
{
if (_cacheDependencyManager == null)
{
return;
}
if (_cacheDependencyManager.IsOkToActOnDependencyKeysForParent(parentKey) && dataToAdd != null)
{
_cacheDependencyManager.AssociateDependentKeysToParent(parentKey, new[] { cacheKey }, action);
}
}
public void Add(string cacheKey, TimeSpan slidingExpiryWindow, object dataToAdd, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems)
{
if (!_config.IsCacheEnabled)
{
return;
}
_cache.Add(cacheKey, slidingExpiryWindow, dataToAdd);
ManageCacheDependenciesForCacheItem(dataToAdd, cacheKey, parentKey, actionForDependency);
}
public void Add(string cacheKey, DateTime absoluteExpiryDate, object dataToAdd, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems)
{
if (!_config.IsCacheEnabled)
{
return;
}
_cache.Add(cacheKey, absoluteExpiryDate, dataToAdd);
ManageCacheDependenciesForCacheItem(dataToAdd, cacheKey, parentKey, actionForDependency);
}
public T Get <T>(TimeSpan slidingExpiryWindow, Func <T> getData, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems) where T : class
{
return(Get(GetCacheKeyFromFuncDelegate(getData), slidingExpiryWindow, getData, parentKey, actionForDependency));
}
public T Get <T>(DateTime absoluteExpiryDate, Func <T> getData, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems) where T : class
{
return(Get(GetCacheKeyFromFuncDelegate(getData), absoluteExpiryDate, getData, parentKey, actionForDependency));
}
public override void AssociateDependentKeysToParent(string parentKey, IEnumerable <string> dependentCacheKeys, CacheDependencyAction actionToPerform = CacheDependencyAction.ClearDependentItems)
{
Logger.WriteInfoMessage(string.Format("Associating list of cache keys to parent key:[{0}]", parentKey));
var cacheKeyForDependency = GetParentItemCacheKey(parentKey);
var currentEntry = Cache.Get <DependencyItem[]>(cacheKeyForDependency);
var tempList = new List <DependencyItem>();
if (currentEntry != null && currentEntry.Length > 0)
{
Logger.WriteInfoMessage(string.Format("Creating new associated dependency list for parent key:[{0}]", parentKey));
tempList.AddRange(currentEntry);
}
else
{
RegisterParentDependencyDefinition(parentKey, actionToPerform);
var items = Cache.Get <DependencyItem[]>(cacheKeyForDependency);
if (items != null)
{
tempList.AddRange(items);
}
}
var keysList = new List <string>(dependentCacheKeys);
keysList.ForEach(d =>
{
if (!tempList.Any(c => c.CacheKey == d))
{
tempList.Add(new DependencyItem {
CacheKey = d, Action = actionToPerform
});
}
});
Cache.InvalidateCacheItem(cacheKeyForDependency);
Cache.Add(cacheKeyForDependency, GetMaxAge(), tempList.ToArray());
}
public abstract void AssociateDependentKeysToParent(string parentKey, IEnumerable <string> dependentCacheKeys, CacheDependencyAction actionToPerform = CacheDependencyAction.ClearDependentItems);
public virtual void ForceActionForDependenciesAssociatedWithParent(string parentKey, CacheDependencyAction forcedAction)
{
Logger.WriteInfoMessage(string.Format("Forcing action:[{0}] on dependency cache keys for parent key:[{1}]", forcedAction.ToString(), parentKey));
ExecuteDefaultOrSuppliedActionForParentKeyDependencies(parentKey, forcedAction);
}
public Task <T> GetAsync <T>(DateTime absoluteExpiryDate, Func <Task <T> > getData, string parentKey = null, CacheDependencyAction actionForDependency = CacheDependencyAction.ClearDependentItems) where T : class
{
return(GetAsync <T>(getData.GetCacheKey(), absoluteExpiryDate, getData, parentKey, actionForDependency));
}
