BaseCacheManager.cs

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Globalization;
usingSystem.Linq;
usingCacheManager.Core.Internal;
usingMicrosoft.Extensions.Logging;
usingstaticCacheManager.Core.Utility.Guard;

namespaceCacheManager.Core
{
/// <summary>
/// The <see cref="BaseCacheManager{TCacheValue}"/> implements <see cref="ICacheManager{TCacheValue}"/> and is the main class
/// of this library.
/// The cache manager delegates all cache operations to the list of <see cref="BaseCacheHandle{T}"/>'s which have been
/// added. It will keep them in sync according to rules and depending on the configuration.
/// </summary>
/// <typeparam name="TCacheValue">The type of the cache value.</typeparam>
publicpartialclassBaseCacheManager<TCacheValue>:BaseCache<TCacheValue>,ICacheManager<TCacheValue>,IDisposable
{
privateclassNullLoggerFactory:ILoggerFactory
{
publicvoidAddProvider(ILoggerProviderprovider)
{
}

publicILoggerCreateLogger(stringcategoryName)
{
returnnewNullLogger();
}

publicvoidDispose()
{
}
}

privateclassNullLogger:ILogger<BaseCacheManager<TCacheValue>>
{
publicIDisposableBeginScope<TState>(TStatestate)=>null;

publicboolIsEnabled(LogLevellogLevel)=>false;

publicvoidLog<TState>(LogLevellogLevel,EventIdeventId,TStatestate,Exceptionexception,Func<TState,Exception,string>formatter)
{
// do nothing;
}
}

privatereadonlybool_logTrace=false;
privatereadonlyBaseCacheHandle<TCacheValue>[]_cacheHandles;
privatereadonlyCacheBackplane_cacheBackplane;

/// <summary>
/// Initializes a new instance of the <see cref="BaseCacheManager{TCacheValue}"/> class
/// using the specified <paramref name="configuration"/>.
/// If the name of the <paramref name="configuration"/> is defined, the cache manager will
/// use it. Otherwise a random string will be generated.
/// </summary>
/// <param name="configuration">
/// The configuration which defines the structure and complexity of the cache manager.
/// </param>
/// <param name="loggerFactory">Optional logger factory.</param>
/// <exception cref="System.ArgumentNullException">
/// When <paramref name="configuration"/> is null.
/// </exception>
/// <see cref="CacheFactory"/>
/// <see cref="CacheConfigurationBuilder"/>
/// <see cref="BaseCacheHandle{TCacheValue}"/>
publicBaseCacheManager(ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory=null)
:this(configuration?.Name??Guid.NewGuid().ToString(),configuration,loggerFactory??newNullLoggerFactory())
{
}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage","CA2200:RethrowToPreserveStackDetails",Justification="fine for now")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability","CA2000:Dispose objects before losing scope",Justification="nope")]
privateBaseCacheManager(stringname,ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory)
{
NotNullOrWhiteSpace(name,nameof(name));
NotNull(configuration,nameof(configuration));
NotNull(loggerFactory,nameof(loggerFactory));

Name=name;
Configuration=configuration;
varserializer=CacheReflectionHelper.CreateSerializer(configuration,loggerFactory);

Logger=loggerFactory.CreateLogger(this.GetType());

_logTrace=Logger.IsEnabled(LogLevel.Trace);

Logger.LogInformation("Cache manager: adding cache handles...");

try
{
_cacheHandles=CacheReflectionHelper.CreateCacheHandles(this,loggerFactory,serializer).ToArray();

varindex=0;
foreach(varhandlein_cacheHandles)
{
varhandleIndex=index;
handle.OnCacheSpecificRemove+=(sender,args)=>
{
// added sync for using backplane with in-memory caches on cache specific removal
// but commented for now, this is not really needed if all instances use the same expiration etc, would just cause duplicated events
////if (_cacheBackplane != null && handle.Configuration.IsBackplaneSource && !handle.IsDistributedCache)
////{
//// if (string.IsNullOrEmpty(args.Region))
//// {
//// _cacheBackplane.NotifyRemove(args.Key);
//// }
//// else
//// {
//// _cacheBackplane.NotifyRemove(args.Key, args.Region);
//// }
////}

// base cache handle does logging for this

if(Configuration.UpdateMode==CacheUpdateMode.Up)
{
if(_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.",handleIndex);
}

EvictFromHandlesAbove(args.Key,args.Region,handleIndex);
}

// moving down below cleanup, otherwise the item could still be in memory
TriggerOnRemoveByHandle(args.Key,args.Region,args.Reason,handleIndex+1,args.Value);
};

index++;
}

_cacheBackplane=CacheReflectionHelper.CreateBackplane(configuration,loggerFactory);
if(_cacheBackplane!=null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch(Exceptionex)
{
Logger.LogError(ex,"Error occurred while creating the cache manager.");
throwex.InnerException??ex;
}
}

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnAdd;

/// <inheritdoc />
publiceventEventHandler<CacheClearEventArgs>OnClear;

/// <inheritdoc />
publiceventEventHandler<CacheClearRegionEventArgs>OnClearRegion;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnGet;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnPut;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnRemove;

/// <inheritdoc />
publiceventEventHandler<CacheItemRemovedEventArgs>OnRemoveByHandle;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnUpdate;

/// <inheritdoc />
publicIReadOnlyCacheManagerConfigurationConfiguration{get;}

/// <inheritdoc />
publicIEnumerable<BaseCacheHandle<TCacheValue>>CacheHandles
=>newReadOnlyCollection<BaseCacheHandle<TCacheValue>>(
newList<BaseCacheHandle<TCacheValue>>(
_cacheHandles));

/// <summary>
/// Gets the configured cache backplane.
/// </summary>
/// <value>The backplane.</value>
publicCacheBackplaneBackplane=>_cacheBackplane;

/// <summary>
/// Gets the cache name.
/// </summary>
/// <value>The name of the cache.</value>
publicstringName{get;}

/// <inheritdoc />
protectedoverrideILoggerLogger{get;}

/// <inheritdoc />
publicoverridevoidClear()
{
CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear: flushing cache...");
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear: clearing handle {0}.",handle.Configuration.Name);
}

handle.Clear();
handle.Stats.OnClear();
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear: notifies backplane.");
}

_cacheBackplane.NotifyClear();
}

TriggerOnClear();
}

/// <inheritdoc />
publicoverridevoidClearRegion(stringregion)
{
NotNullOrWhiteSpace(region,nameof(region));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}.",region);
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0} in handle {1}.",region,handle.Configuration.Name);
}

handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}: notifies backplane [clear region].",region);
}

_cacheBackplane.NotifyClearRegion(region);
}

TriggerOnClearRegion(region);
}

/// <inheritdoc />
publicoverrideboolExists(stringkey)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}] exists on handle '{1}'.",key,handle.Configuration.Name);
}

if(handle.Exists(key))
{
returntrue;
}
}

returnfalse;
}

/// <inheritdoc />
publicoverrideboolExists(stringkey,stringregion)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}:{1}] exists on handle '{2}'.",region,key,handle.Configuration.Name);
}

if(handle.Exists(key,region))
{
returntrue;
}
}

returnfalse;
}

/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
publicoverridestringToString()=>
string.Format(CultureInfo.InvariantCulture,"Name: {0}, Handles: [{1}]",Name,string.Join(",",_cacheHandles.Select(p =>p.GetType().Name)));

/// <inheritdoc />
protectedinternaloverrideboolAddInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Add [{0}] started.",item);
}

varhandleIndex=_cacheHandles.Length-1;

varresult=AddItemToHandle(item,_cacheHandles[handleIndex]);

// evict from other handles in any case because if it exists, it might be a different version
// if not exist, its just a sanity check to invalidate other versions in upper layers.
EvictFromOtherHandles(item.Key,item.Region,handleIndex);

if(result)
{
// update backplane
if(_cacheBackplane!=null)
{
if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Add);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Add);
}

if(_logTrace)
{
Logger.LogTrace("Notified backplane 'change' because [{0}] was added.",item);
}
}

// trigger only once and not per handle and only if the item was added!
TriggerOnAdd(item.Key,item.Region);
}

returnresult;
}

/// <inheritdoc />
protectedinternaloverridevoidPutInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Put [{0}] started.",item);
}

foreach(varhandlein_cacheHandles)
{
if(handle.Configuration.EnableStatistics)
{
// check if it is really a new item otherwise the items count is crap because we
// count it every time, but use only the current handle to retrieve the item,
// otherwise we would trigger gets and find it in another handle maybe
varoldItem=string.IsNullOrWhiteSpace(item.Region)?
handle.GetCacheItem(item.Key):
handle.GetCacheItem(item.Key,item.Region);

handle.Stats.OnPut(item,oldItem==null);
}

if(_logTrace)
{
Logger.LogTrace(
"Put [{0}:{1}] successfully to handle '{2}'.",
item.Region,
item.Key,
handle.Configuration.Name);
}

handle.Put(item);
}

// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Put [{0}:{1}] was scuccessful. Notifying backplane [change].",item.Region,item.Key);
}

if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Put);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Put);
}
}

TriggerOnPut(item.Key,item.Region);
}

/// <inheritdoc />
protectedoverridevoidDispose(booldisposeManaged)
{
if(disposeManaged)
{
foreach(varhandlein_cacheHandles)
{
handle.Dispose();
}

if(_cacheBackplane!=null)
{
_cacheBackplane.Dispose();
}
}

base.Dispose(disposeManaged);
}

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey)=>
GetCacheItemInternal(key,null);

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey,stringregion)
{
CheckDisposed();

CacheItem<TCacheValue>cacheItem=null;

if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}] started.",region,key);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
varhandle=_cacheHandles[handleIndex];
if(string.IsNullOrWhiteSpace(region))
{
cacheItem=handle.GetCacheItem(key);
}
else
{
cacheItem=handle.GetCacheItem(key,region);
}

handle.Stats.OnGet(region);

if(cacheItem!=null)
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

// update last accessed, might be used for custom sliding implementations
cacheItem.LastAccessedUtc=DateTime.UtcNow;

// update other handles if needed
AddToHandles(cacheItem,handleIndex);
handle.Stats.OnHit(region);
TriggerOnGet(key,region);
break;
}
else
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], item NOT found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

handle.Stats.OnMiss(region);
}
}

returncacheItem;
}

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey)=>
RemoveInternal(key,null);

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey,stringregion)
{
CheckDisposed();

varresult=false;

if(_logTrace)
{
Logger.LogTrace("Removing [{0}:{1}].",region,key);
}

foreach(varhandlein_cacheHandles)
{
varhandleResult=false;
if(!string.IsNullOrWhiteSpace(region))
{
handleResult=handle.Remove(key,region);
}
else
{
handleResult=handle.Remove(key);
}

if(handleResult)
{
if(_logTrace)
{
Logger.LogTrace(
"Remove [{0}:{1}], successfully removed from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

result=true;
handle.Stats.OnRemove(region);
}
}

// See #311, send remove events anyways if the backlane is configured but no distributed cache is used.
varinProcOnly=_cacheHandles.Any(p =>!p.IsDistributedCache);

if(result||inProcOnly)
{
// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Removed [{0}:{1}], notifying backplane [remove].",region,key);
}

if(string.IsNullOrWhiteSpace(region))
{
_cacheBackplane.NotifyRemove(key);
}
else
{
_cacheBackplane.NotifyRemove(key,region);
}
}

if(result)
{
// trigger only once and not per handle
TriggerOnRemove(key,region);
}
}

returnresult;
}

privatestaticboolAddItemToHandle(CacheItem<TCacheValue>item,BaseCacheHandle<TCacheValue>handle)
{
if(handle.Add(item))
{
handle.Stats.OnAdd(item);
returntrue;
}

returnfalse;
}

privatestaticvoidClearHandles(BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.Clear();
handle.Stats.OnClear();
}

////this.TriggerOnClear();
}

privatestaticvoidClearRegionHandles(stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

////this.TriggerOnClearRegion(region);
}

privatevoidEvictFromHandles(stringkey,stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
EvictFromHandle(key,region,handle);
}
}

privatevoidEvictFromHandle(stringkey,stringregion,BaseCacheHandle<TCacheValue>handle)
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug(
"Evicting '{0}:{1}' from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

boolresult;
if(string.IsNullOrWhiteSpace(region))
{
result=handle.Remove(key);
}
else
{
result=handle.Remove(key,region);
}

if(result)
{
handle.Stats.OnRemove(region);
}
}

privatevoidAddToHandles(CacheItem<TCacheValue>item,intfoundIndex)
{
if(_logTrace)
{
Logger.LogTrace(
"Start updating handles with [{0}].",
item);
}

if(foundIndex==0)
{
return;
}

// update all cache handles with lower order, up the list
for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<foundIndex)
{
if(_logTrace)
{
Logger.LogTrace("Updating handles, added [{0}] to handle '{1}'.",item,_cacheHandles[handleIndex].Configuration.Name);
}

_cacheHandles[handleIndex].Add(item);
}
}
}

privatevoidAddToHandlesBelow(CacheItem<TCacheValue>item,intfoundIndex)
{
if(item==null)
{
return;
}

if(_logTrace)
{
Logger.LogTrace("Add [{0}] to handles below handle '{1}'.",item,foundIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex>foundIndex)
{
if(_cacheHandles[handleIndex].Add(item))
{
_cacheHandles[handleIndex].Stats.OnAdd(item);
}
}
}
}

privatevoidEvictFromOtherHandles(stringkey,stringregion,intexcludeIndex)
{
if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

if(_logTrace)
{
Logger.LogTrace("Evict [{0}:{1}] from other handles excluding handle '{2}'.",region,key,excludeIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex!=excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidEvictFromHandlesAbove(stringkey,stringregion,intexcludeIndex)
{
if(_logTrace)
{
Logger.LogTrace("Evict from handles above: {0} {1}: above handle {2}.",key,region,excludeIndex);
}

if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidRegisterCacheBackplane(CacheBackplanebackplane)
{
NotNull(backplane,nameof(backplane));

// this should have been checked during activation already, just to be totally sure...
if(_cacheHandles.Any(p =>p.Configuration.IsBackplaneSource))
{
// added includeSource param to get the handles which need to be synced.
// in case the backplane source is non-distributed (in-memory), only remotely triggered remove and clear should also
// trigger a sync locally. For distributed caches, we expect that the distributed cache is already the source and in sync
// as that's the layer which triggered the event. In this case, only other in-memory handles above the distributed, would be synced.
varhandles=newFunc<bool,BaseCacheHandle<TCacheValue>[]>((includeSource)=>
{
varhandleList=newList<BaseCacheHandle<TCacheValue>>();
foreach(varhandlein_cacheHandles)
{
if(!handle.Configuration.IsBackplaneSource||
(includeSource&&handle.Configuration.IsBackplaneSource&&!handle.IsDistributedCache))
{
handleList.Add(handle);
}
}
returnhandleList.ToArray();
});

backplane.Changed+=(sender,args)=>
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Backplane event: [Changed] for '{1}:{0}'.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(false));
switch(args.Action)
{
caseCacheItemChangedEventAction.Add:
TriggerOnAdd(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Put:
TriggerOnPut(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Update:
TriggerOnUpdate(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;
}
};

backplane.Removed+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Remove] of {0} {1}.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(true));
TriggerOnRemove(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
};

backplane.Cleared+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear].");
}

ClearHandles(handles(true));
TriggerOnClear(CacheActionEventArgOrigin.Remote);
};

backplane.ClearedRegion+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear Region] region: {0}.",args.Region);
}

ClearRegionHandles(args.Region,handles(true));
TriggerOnClearRegion(args.Region,CacheActionEventArgOrigin.Remote);
};
}
}

privatevoidTriggerOnAdd(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnAdd?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnClear(CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClear?.Invoke(this,newCacheClearEventArgs(origin));
}

privatevoidTriggerOnClearRegion(stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClearRegion?.Invoke(this,newCacheClearRegionEventArgs(region,origin));
}

privatevoidTriggerOnGet(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnGet?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnPut(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnPut?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemove(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemove?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemoveByHandle(stringkey,stringregion,CacheItemRemovedReasonreason,intlevel,objectvalue)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemoveByHandle?.Invoke(this,newCacheItemRemovedEventArgs(key,region,reason,value,level));
}

privatevoidTriggerOnUpdate(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnUpdate?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}
}
}
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Globalization;
usingSystem.Linq;
usingCacheManager.Core.Internal;
usingMicrosoft.Extensions.Logging;
usingstaticCacheManager.Core.Utility.Guard;

namespaceCacheManager.Core
{
/// <summary>
/// The <see cref="BaseCacheManager{TCacheValue}"/> implements <see cref="ICacheManager{TCacheValue}"/> and is the main class
/// of this library.
/// The cache manager delegates all cache operations to the list of <see cref="BaseCacheHandle{T}"/>'s which have been
/// added. It will keep them in sync according to rules and depending on the configuration.
/// </summary>
/// <typeparam name="TCacheValue">The type of the cache value.</typeparam>
publicpartialclassBaseCacheManager<TCacheValue>:BaseCache<TCacheValue>,ICacheManager<TCacheValue>,IDisposable
{
privateclassNullLoggerFactory:ILoggerFactory
{
publicvoidAddProvider(ILoggerProviderprovider)
{
}

publicILoggerCreateLogger(stringcategoryName)
{
returnnewNullLogger();
}

publicvoidDispose()
{
}
}

privateclassNullLogger:ILogger<BaseCacheManager<TCacheValue>>
{
publicIDisposableBeginScope<TState>(TStatestate)=>null;

publicboolIsEnabled(LogLevellogLevel)=>false;

publicvoidLog<TState>(LogLevellogLevel,EventIdeventId,TStatestate,Exceptionexception,Func<TState,Exception,string>formatter)
{
// do nothing;
}
}

privatereadonlybool_logTrace=false;
privatereadonlyBaseCacheHandle<TCacheValue>[]_cacheHandles;
privatereadonlyCacheBackplane_cacheBackplane;

/// <summary>
/// Initializes a new instance of the <see cref="BaseCacheManager{TCacheValue}"/> class
/// using the specified <paramref name="configuration"/>.
/// If the name of the <paramref name="configuration"/> is defined, the cache manager will
/// use it. Otherwise a random string will be generated.
/// </summary>
/// <param name="configuration">
/// The configuration which defines the structure and complexity of the cache manager.
/// </param>
/// <param name="loggerFactory">Optional logger factory.</param>
/// <exception cref="System.ArgumentNullException">
/// When <paramref name="configuration"/> is null.
/// </exception>
/// <see cref="CacheFactory"/>
/// <see cref="CacheConfigurationBuilder"/>
/// <see cref="BaseCacheHandle{TCacheValue}"/>
publicBaseCacheManager(ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory=null)
:this(configuration?.Name??Guid.NewGuid().ToString(),configuration,loggerFactory??newNullLoggerFactory())
{
}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage","CA2200:RethrowToPreserveStackDetails",Justification="fine for now")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability","CA2000:Dispose objects before losing scope",Justification="nope")]
privateBaseCacheManager(stringname,ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory)
{
NotNullOrWhiteSpace(name,nameof(name));
NotNull(configuration,nameof(configuration));
NotNull(loggerFactory,nameof(loggerFactory));

Name=name;
Configuration=configuration;
varserializer=CacheReflectionHelper.CreateSerializer(configuration,loggerFactory);

Logger=loggerFactory.CreateLogger(this.GetType());

_logTrace=Logger.IsEnabled(LogLevel.Trace);

Logger.LogInformation("Cache manager: adding cache handles...");

try
{
_cacheHandles=CacheReflectionHelper.CreateCacheHandles(this,loggerFactory,serializer).ToArray();

varindex=0;
foreach(varhandlein_cacheHandles)
{
varhandleIndex=index;
handle.OnCacheSpecificRemove+=(sender,args)=>
{
// added sync for using backplane with in-memory caches on cache specific removal
// but commented for now, this is not really needed if all instances use the same expiration etc, would just cause duplicated events
////if (_cacheBackplane != null && handle.Configuration.IsBackplaneSource && !handle.IsDistributedCache)
////{
//// if (string.IsNullOrEmpty(args.Region))
//// {
//// _cacheBackplane.NotifyRemove(args.Key);
//// }
//// else
//// {
//// _cacheBackplane.NotifyRemove(args.Key, args.Region);
//// }
////}

// base cache handle does logging for this

if(Configuration.UpdateMode==CacheUpdateMode.Up)
{
if(_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.",handleIndex);
}

EvictFromHandlesAbove(args.Key,args.Region,handleIndex);
}

// moving down below cleanup, otherwise the item could still be in memory
TriggerOnRemoveByHandle(args.Key,args.Region,args.Reason,handleIndex+1,args.Value);
};

index++;
}

_cacheBackplane=CacheReflectionHelper.CreateBackplane(configuration,loggerFactory);
if(_cacheBackplane!=null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch(Exceptionex)
{
Logger.LogError(ex,"Error occurred while creating the cache manager.");
throwex.InnerException??ex;
}
}

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnAdd;

/// <inheritdoc />
publiceventEventHandler<CacheClearEventArgs>OnClear;

/// <inheritdoc />
publiceventEventHandler<CacheClearRegionEventArgs>OnClearRegion;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnGet;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnPut;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnRemove;

/// <inheritdoc />
publiceventEventHandler<CacheItemRemovedEventArgs>OnRemoveByHandle;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnUpdate;

/// <inheritdoc />
publicIReadOnlyCacheManagerConfigurationConfiguration{get;}

/// <inheritdoc />
publicIEnumerable<BaseCacheHandle<TCacheValue>>CacheHandles
=>newReadOnlyCollection<BaseCacheHandle<TCacheValue>>(
newList<BaseCacheHandle<TCacheValue>>(
_cacheHandles));

/// <summary>
/// Gets the configured cache backplane.
/// </summary>
/// <value>The backplane.</value>
publicCacheBackplaneBackplane=>_cacheBackplane;

/// <summary>
/// Gets the cache name.
/// </summary>
/// <value>The name of the cache.</value>
publicstringName{get;}

/// <inheritdoc />
protectedoverrideILoggerLogger{get;}

/// <inheritdoc />
publicoverridevoidClear()
{
CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear: flushing cache...");
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear: clearing handle {0}.",handle.Configuration.Name);
}

handle.Clear();
handle.Stats.OnClear();
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear: notifies backplane.");
}

_cacheBackplane.NotifyClear();
}

TriggerOnClear();
}

/// <inheritdoc />
publicoverridevoidClearRegion(stringregion)
{
NotNullOrWhiteSpace(region,nameof(region));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}.",region);
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0} in handle {1}.",region,handle.Configuration.Name);
}

handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}: notifies backplane [clear region].",region);
}

_cacheBackplane.NotifyClearRegion(region);
}

TriggerOnClearRegion(region);
}

/// <inheritdoc />
publicoverrideboolExists(stringkey)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}] exists on handle '{1}'.",key,handle.Configuration.Name);
}

if(handle.Exists(key))
{
returntrue;
}
}

returnfalse;
}

/// <inheritdoc />
publicoverrideboolExists(stringkey,stringregion)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}:{1}] exists on handle '{2}'.",region,key,handle.Configuration.Name);
}

if(handle.Exists(key,region))
{
returntrue;
}
}

returnfalse;
}

/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
publicoverridestringToString()=>
string.Format(CultureInfo.InvariantCulture,"Name: {0}, Handles: [{1}]",Name,string.Join(",",_cacheHandles.Select(p =>p.GetType().Name)));

/// <inheritdoc />
protectedinternaloverrideboolAddInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Add [{0}] started.",item);
}

varhandleIndex=_cacheHandles.Length-1;

varresult=AddItemToHandle(item,_cacheHandles[handleIndex]);

// evict from other handles in any case because if it exists, it might be a different version
// if not exist, its just a sanity check to invalidate other versions in upper layers.
EvictFromOtherHandles(item.Key,item.Region,handleIndex);

if(result)
{
// update backplane
if(_cacheBackplane!=null)
{
if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Add);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Add);
}

if(_logTrace)
{
Logger.LogTrace("Notified backplane 'change' because [{0}] was added.",item);
}
}

// trigger only once and not per handle and only if the item was added!
TriggerOnAdd(item.Key,item.Region);
}

returnresult;
}

/// <inheritdoc />
protectedinternaloverridevoidPutInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Put [{0}] started.",item);
}

foreach(varhandlein_cacheHandles)
{
if(handle.Configuration.EnableStatistics)
{
// check if it is really a new item otherwise the items count is crap because we
// count it every time, but use only the current handle to retrieve the item,
// otherwise we would trigger gets and find it in another handle maybe
varoldItem=string.IsNullOrWhiteSpace(item.Region)?
handle.GetCacheItem(item.Key):
handle.GetCacheItem(item.Key,item.Region);

handle.Stats.OnPut(item,oldItem==null);
}

if(_logTrace)
{
Logger.LogTrace(
"Put [{0}:{1}] successfully to handle '{2}'.",
item.Region,
item.Key,
handle.Configuration.Name);
}

handle.Put(item);
}

// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Put [{0}:{1}] was scuccessful. Notifying backplane [change].",item.Region,item.Key);
}

if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Put);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Put);
}
}

TriggerOnPut(item.Key,item.Region);
}

/// <inheritdoc />
protectedoverridevoidDispose(booldisposeManaged)
{
if(disposeManaged)
{
foreach(varhandlein_cacheHandles)
{
handle.Dispose();
}

if(_cacheBackplane!=null)
{
_cacheBackplane.Dispose();
}
}

base.Dispose(disposeManaged);
}

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey)=>
GetCacheItemInternal(key,null);

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey,stringregion)
{
CheckDisposed();

CacheItem<TCacheValue>cacheItem=null;

if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}] started.",region,key);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
varhandle=_cacheHandles[handleIndex];
if(string.IsNullOrWhiteSpace(region))
{
cacheItem=handle.GetCacheItem(key);
}
else
{
cacheItem=handle.GetCacheItem(key,region);
}

handle.Stats.OnGet(region);

if(cacheItem!=null)
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

// update last accessed, might be used for custom sliding implementations
cacheItem.LastAccessedUtc=DateTime.UtcNow;

// update other handles if needed
AddToHandles(cacheItem,handleIndex);
handle.Stats.OnHit(region);
TriggerOnGet(key,region);
break;
}
else
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], item NOT found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

handle.Stats.OnMiss(region);
}
}

returncacheItem;
}

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey)=>
RemoveInternal(key,null);

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey,stringregion)
{
CheckDisposed();

varresult=false;

if(_logTrace)
{
Logger.LogTrace("Removing [{0}:{1}].",region,key);
}

foreach(varhandlein_cacheHandles)
{
varhandleResult=false;
if(!string.IsNullOrWhiteSpace(region))
{
handleResult=handle.Remove(key,region);
}
else
{
handleResult=handle.Remove(key);
}

if(handleResult)
{
if(_logTrace)
{
Logger.LogTrace(
"Remove [{0}:{1}], successfully removed from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

result=true;
handle.Stats.OnRemove(region);
}
}

// See #311, send remove events anyways if the backlane is configured but no distributed cache is used.
varinProcOnly=_cacheHandles.Any(p =>!p.IsDistributedCache);

if(result||inProcOnly)
{
// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Removed [{0}:{1}], notifying backplane [remove].",region,key);
}

if(string.IsNullOrWhiteSpace(region))
{
_cacheBackplane.NotifyRemove(key);
}
else
{
_cacheBackplane.NotifyRemove(key,region);
}
}

if(result)
{
// trigger only once and not per handle
TriggerOnRemove(key,region);
}
}

returnresult;
}

privatestaticboolAddItemToHandle(CacheItem<TCacheValue>item,BaseCacheHandle<TCacheValue>handle)
{
if(handle.Add(item))
{
handle.Stats.OnAdd(item);
returntrue;
}

returnfalse;
}

privatestaticvoidClearHandles(BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.Clear();
handle.Stats.OnClear();
}

////this.TriggerOnClear();
}

privatestaticvoidClearRegionHandles(stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

////this.TriggerOnClearRegion(region);
}

privatevoidEvictFromHandles(stringkey,stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
EvictFromHandle(key,region,handle);
}
}

privatevoidEvictFromHandle(stringkey,stringregion,BaseCacheHandle<TCacheValue>handle)
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug(
"Evicting '{0}:{1}' from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

boolresult;
if(string.IsNullOrWhiteSpace(region))
{
result=handle.Remove(key);
}
else
{
result=handle.Remove(key,region);
}

if(result)
{
handle.Stats.OnRemove(region);
}
}

privatevoidAddToHandles(CacheItem<TCacheValue>item,intfoundIndex)
{
if(_logTrace)
{
Logger.LogTrace(
"Start updating handles with [{0}].",
item);
}

if(foundIndex==0)
{
return;
}

// update all cache handles with lower order, up the list
for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<foundIndex)
{
if(_logTrace)
{
Logger.LogTrace("Updating handles, added [{0}] to handle '{1}'.",item,_cacheHandles[handleIndex].Configuration.Name);
}

_cacheHandles[handleIndex].Add(item);
}
}
}

privatevoidAddToHandlesBelow(CacheItem<TCacheValue>item,intfoundIndex)
{
if(item==null)
{
return;
}

if(_logTrace)
{
Logger.LogTrace("Add [{0}] to handles below handle '{1}'.",item,foundIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex>foundIndex)
{
if(_cacheHandles[handleIndex].Add(item))
{
_cacheHandles[handleIndex].Stats.OnAdd(item);
}
}
}
}

privatevoidEvictFromOtherHandles(stringkey,stringregion,intexcludeIndex)
{
if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

if(_logTrace)
{
Logger.LogTrace("Evict [{0}:{1}] from other handles excluding handle '{2}'.",region,key,excludeIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex!=excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidEvictFromHandlesAbove(stringkey,stringregion,intexcludeIndex)
{
if(_logTrace)
{
Logger.LogTrace("Evict from handles above: {0} {1}: above handle {2}.",key,region,excludeIndex);
}

if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidRegisterCacheBackplane(CacheBackplanebackplane)
{
NotNull(backplane,nameof(backplane));

// this should have been checked during activation already, just to be totally sure...
if(_cacheHandles.Any(p =>p.Configuration.IsBackplaneSource))
{
// added includeSource param to get the handles which need to be synced.
// in case the backplane source is non-distributed (in-memory), only remotely triggered remove and clear should also
// trigger a sync locally. For distributed caches, we expect that the distributed cache is already the source and in sync
// as that's the layer which triggered the event. In this case, only other in-memory handles above the distributed, would be synced.
varhandles=newFunc<bool,BaseCacheHandle<TCacheValue>[]>((includeSource)=>
{
varhandleList=newList<BaseCacheHandle<TCacheValue>>();
foreach(varhandlein_cacheHandles)
{
if(!handle.Configuration.IsBackplaneSource||
(includeSource&&handle.Configuration.IsBackplaneSource&&!handle.IsDistributedCache))
{
handleList.Add(handle);
}
}
returnhandleList.ToArray();
});

backplane.Changed+=(sender,args)=>
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Backplane event: [Changed] for '{1}:{0}'.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(false));
switch(args.Action)
{
caseCacheItemChangedEventAction.Add:
TriggerOnAdd(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Put:
TriggerOnPut(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Update:
TriggerOnUpdate(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;
}
};

backplane.Removed+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Remove] of {0} {1}.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(true));
TriggerOnRemove(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
};

backplane.Cleared+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear].");
}

ClearHandles(handles(true));
TriggerOnClear(CacheActionEventArgOrigin.Remote);
};

backplane.ClearedRegion+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear Region] region: {0}.",args.Region);
}

ClearRegionHandles(args.Region,handles(true));
TriggerOnClearRegion(args.Region,CacheActionEventArgOrigin.Remote);
};
}
}

privatevoidTriggerOnAdd(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnAdd?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnClear(CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClear?.Invoke(this,newCacheClearEventArgs(origin));
}

privatevoidTriggerOnClearRegion(stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClearRegion?.Invoke(this,newCacheClearRegionEventArgs(region,origin));
}

privatevoidTriggerOnGet(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnGet?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnPut(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnPut?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemove(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemove?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemoveByHandle(stringkey,stringregion,CacheItemRemovedReasonreason,intlevel,objectvalue)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemoveByHandle?.Invoke(this,newCacheItemRemovedEventArgs(key,region,reason,value,level));
}

privatevoidTriggerOnUpdate(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnUpdate?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}
}
}
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Globalization;
usingSystem.Linq;
usingCacheManager.Core.Internal;
usingMicrosoft.Extensions.Logging;
usingstaticCacheManager.Core.Utility.Guard;

namespaceCacheManager.Core
{
/// <summary>
/// The <see cref="BaseCacheManager{TCacheValue}"/> implements <see cref="ICacheManager{TCacheValue}"/> and is the main class
/// of this library.
/// The cache manager delegates all cache operations to the list of <see cref="BaseCacheHandle{T}"/>'s which have been
/// added. It will keep them in sync according to rules and depending on the configuration.
/// </summary>
/// <typeparam name="TCacheValue">The type of the cache value.</typeparam>
publicpartialclassBaseCacheManager<TCacheValue>:BaseCache<TCacheValue>,ICacheManager<TCacheValue>,IDisposable
{
privateclassNullLoggerFactory:ILoggerFactory
{
publicvoidAddProvider(ILoggerProviderprovider)
{
}

publicILoggerCreateLogger(stringcategoryName)
{
returnnewNullLogger();
}

publicvoidDispose()
{
}
}

privateclassNullLogger:ILogger<BaseCacheManager<TCacheValue>>
{
publicIDisposableBeginScope<TState>(TStatestate)=>null;

publicboolIsEnabled(LogLevellogLevel)=>false;

publicvoidLog<TState>(LogLevellogLevel,EventIdeventId,TStatestate,Exceptionexception,Func<TState,Exception,string>formatter)
{
// do nothing;
}
}

privatereadonlybool_logTrace=false;
privatereadonlyBaseCacheHandle<TCacheValue>[]_cacheHandles;
privatereadonlyCacheBackplane_cacheBackplane;

/// <summary>
/// Initializes a new instance of the <see cref="BaseCacheManager{TCacheValue}"/> class
/// using the specified <paramref name="configuration"/>.
/// If the name of the <paramref name="configuration"/> is defined, the cache manager will
/// use it. Otherwise a random string will be generated.
/// </summary>
/// <param name="configuration">
/// The configuration which defines the structure and complexity of the cache manager.
/// </param>
/// <param name="loggerFactory">Optional logger factory.</param>
/// <exception cref="System.ArgumentNullException">
/// When <paramref name="configuration"/> is null.
/// </exception>
/// <see cref="CacheFactory"/>
/// <see cref="CacheConfigurationBuilder"/>
/// <see cref="BaseCacheHandle{TCacheValue}"/>
publicBaseCacheManager(ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory=null)
:this(configuration?.Name??Guid.NewGuid().ToString(),configuration,loggerFactory??newNullLoggerFactory())
{
}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage","CA2200:RethrowToPreserveStackDetails",Justification="fine for now")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability","CA2000:Dispose objects before losing scope",Justification="nope")]
privateBaseCacheManager(stringname,ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory)
{
NotNullOrWhiteSpace(name,nameof(name));
NotNull(configuration,nameof(configuration));
NotNull(loggerFactory,nameof(loggerFactory));

Name=name;
Configuration=configuration;
varserializer=CacheReflectionHelper.CreateSerializer(configuration,loggerFactory);

Logger=loggerFactory.CreateLogger(this.GetType());

_logTrace=Logger.IsEnabled(LogLevel.Trace);

Logger.LogInformation("Cache manager: adding cache handles...");

try
{
_cacheHandles=CacheReflectionHelper.CreateCacheHandles(this,loggerFactory,serializer).ToArray();

varindex=0;
foreach(varhandlein_cacheHandles)
{
varhandleIndex=index;
handle.OnCacheSpecificRemove+=(sender,args)=>
{
// added sync for using backplane with in-memory caches on cache specific removal
// but commented for now, this is not really needed if all instances use the same expiration etc, would just cause duplicated events
////if (_cacheBackplane != null && handle.Configuration.IsBackplaneSource && !handle.IsDistributedCache)
////{
//// if (string.IsNullOrEmpty(args.Region))
//// {
//// _cacheBackplane.NotifyRemove(args.Key);
//// }
//// else
//// {
//// _cacheBackplane.NotifyRemove(args.Key, args.Region);
//// }
////}

// base cache handle does logging for this

if(Configuration.UpdateMode==CacheUpdateMode.Up)
{
if(_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.",handleIndex);
}

EvictFromHandlesAbove(args.Key,args.Region,handleIndex);
}

// moving down below cleanup, otherwise the item could still be in memory
TriggerOnRemoveByHandle(args.Key,args.Region,args.Reason,handleIndex+1,args.Value);
};

index++;
}

_cacheBackplane=CacheReflectionHelper.CreateBackplane(configuration,loggerFactory);
if(_cacheBackplane!=null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch(Exceptionex)
{
Logger.LogError(ex,"Error occurred while creating the cache manager.");
throwex.InnerException??ex;
}
}

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnAdd;

/// <inheritdoc />
publiceventEventHandler<CacheClearEventArgs>OnClear;

/// <inheritdoc />
publiceventEventHandler<CacheClearRegionEventArgs>OnClearRegion;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnGet;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnPut;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnRemove;

/// <inheritdoc />
publiceventEventHandler<CacheItemRemovedEventArgs>OnRemoveByHandle;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnUpdate;

/// <inheritdoc />
publicIReadOnlyCacheManagerConfigurationConfiguration{get;}

/// <inheritdoc />
publicIEnumerable<BaseCacheHandle<TCacheValue>>CacheHandles
=>newReadOnlyCollection<BaseCacheHandle<TCacheValue>>(
newList<BaseCacheHandle<TCacheValue>>(
_cacheHandles));

/// <summary>
/// Gets the configured cache backplane.
/// </summary>
/// <value>The backplane.</value>
publicCacheBackplaneBackplane=>_cacheBackplane;

/// <summary>
/// Gets the cache name.
/// </summary>
/// <value>The name of the cache.</value>
publicstringName{get;}

/// <inheritdoc />
protectedoverrideILoggerLogger{get;}

/// <inheritdoc />
publicoverridevoidClear()
{
CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear: flushing cache...");
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear: clearing handle {0}.",handle.Configuration.Name);
}

handle.Clear();
handle.Stats.OnClear();
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear: notifies backplane.");
}

_cacheBackplane.NotifyClear();
}

TriggerOnClear();
}

/// <inheritdoc />
publicoverridevoidClearRegion(stringregion)
{
NotNullOrWhiteSpace(region,nameof(region));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}.",region);
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0} in handle {1}.",region,handle.Configuration.Name);
}

handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}: notifies backplane [clear region].",region);
}

_cacheBackplane.NotifyClearRegion(region);
}

TriggerOnClearRegion(region);
}

/// <inheritdoc />
publicoverrideboolExists(stringkey)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}] exists on handle '{1}'.",key,handle.Configuration.Name);
}

if(handle.Exists(key))
{
returntrue;
}
}

returnfalse;
}

/// <inheritdoc />
publicoverrideboolExists(stringkey,stringregion)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}:{1}] exists on handle '{2}'.",region,key,handle.Configuration.Name);
}

if(handle.Exists(key,region))
{
returntrue;
}
}

returnfalse;
}

/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
publicoverridestringToString()=>
string.Format(CultureInfo.InvariantCulture,"Name: {0}, Handles: [{1}]",Name,string.Join(",",_cacheHandles.Select(p =>p.GetType().Name)));

/// <inheritdoc />
protectedinternaloverrideboolAddInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Add [{0}] started.",item);
}

varhandleIndex=_cacheHandles.Length-1;

varresult=AddItemToHandle(item,_cacheHandles[handleIndex]);

// evict from other handles in any case because if it exists, it might be a different version
// if not exist, its just a sanity check to invalidate other versions in upper layers.
EvictFromOtherHandles(item.Key,item.Region,handleIndex);

if(result)
{
// update backplane
if(_cacheBackplane!=null)
{
if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Add);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Add);
}

if(_logTrace)
{
Logger.LogTrace("Notified backplane 'change' because [{0}] was added.",item);
}
}

// trigger only once and not per handle and only if the item was added!
TriggerOnAdd(item.Key,item.Region);
}

returnresult;
}

/// <inheritdoc />
protectedinternaloverridevoidPutInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Put [{0}] started.",item);
}

foreach(varhandlein_cacheHandles)
{
if(handle.Configuration.EnableStatistics)
{
// check if it is really a new item otherwise the items count is crap because we
// count it every time, but use only the current handle to retrieve the item,
// otherwise we would trigger gets and find it in another handle maybe
varoldItem=string.IsNullOrWhiteSpace(item.Region)?
handle.GetCacheItem(item.Key):
handle.GetCacheItem(item.Key,item.Region);

handle.Stats.OnPut(item,oldItem==null);
}

if(_logTrace)
{
Logger.LogTrace(
"Put [{0}:{1}] successfully to handle '{2}'.",
item.Region,
item.Key,
handle.Configuration.Name);
}

handle.Put(item);
}

// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Put [{0}:{1}] was scuccessful. Notifying backplane [change].",item.Region,item.Key);
}

if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Put);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Put);
}
}

TriggerOnPut(item.Key,item.Region);
}

/// <inheritdoc />
protectedoverridevoidDispose(booldisposeManaged)
{
if(disposeManaged)
{
foreach(varhandlein_cacheHandles)
{
handle.Dispose();
}

if(_cacheBackplane!=null)
{
_cacheBackplane.Dispose();
}
}

base.Dispose(disposeManaged);
}

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey)=>
GetCacheItemInternal(key,null);

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey,stringregion)
{
CheckDisposed();

CacheItem<TCacheValue>cacheItem=null;

if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}] started.",region,key);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
varhandle=_cacheHandles[handleIndex];
if(string.IsNullOrWhiteSpace(region))
{
cacheItem=handle.GetCacheItem(key);
}
else
{
cacheItem=handle.GetCacheItem(key,region);
}

handle.Stats.OnGet(region);

if(cacheItem!=null)
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

// update last accessed, might be used for custom sliding implementations
cacheItem.LastAccessedUtc=DateTime.UtcNow;

// update other handles if needed
AddToHandles(cacheItem,handleIndex);
handle.Stats.OnHit(region);
TriggerOnGet(key,region);
break;
}
else
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], item NOT found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

handle.Stats.OnMiss(region);
}
}

returncacheItem;
}

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey)=>
RemoveInternal(key,null);

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey,stringregion)
{
CheckDisposed();

varresult=false;

if(_logTrace)
{
Logger.LogTrace("Removing [{0}:{1}].",region,key);
}

foreach(varhandlein_cacheHandles)
{
varhandleResult=false;
if(!string.IsNullOrWhiteSpace(region))
{
handleResult=handle.Remove(key,region);
}
else
{
handleResult=handle.Remove(key);
}

if(handleResult)
{
if(_logTrace)
{
Logger.LogTrace(
"Remove [{0}:{1}], successfully removed from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

result=true;
handle.Stats.OnRemove(region);
}
}

// See #311, send remove events anyways if the backlane is configured but no distributed cache is used.
varinProcOnly=_cacheHandles.Any(p =>!p.IsDistributedCache);

if(result||inProcOnly)
{
// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Removed [{0}:{1}], notifying backplane [remove].",region,key);
}

if(string.IsNullOrWhiteSpace(region))
{
_cacheBackplane.NotifyRemove(key);
}
else
{
_cacheBackplane.NotifyRemove(key,region);
}
}

if(result)
{
// trigger only once and not per handle
TriggerOnRemove(key,region);
}
}

returnresult;
}

privatestaticboolAddItemToHandle(CacheItem<TCacheValue>item,BaseCacheHandle<TCacheValue>handle)
{
if(handle.Add(item))
{
handle.Stats.OnAdd(item);
returntrue;
}

returnfalse;
}

privatestaticvoidClearHandles(BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.Clear();
handle.Stats.OnClear();
}

////this.TriggerOnClear();
}

privatestaticvoidClearRegionHandles(stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

////this.TriggerOnClearRegion(region);
}

privatevoidEvictFromHandles(stringkey,stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
EvictFromHandle(key,region,handle);
}
}

privatevoidEvictFromHandle(stringkey,stringregion,BaseCacheHandle<TCacheValue>handle)
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug(
"Evicting '{0}:{1}' from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

boolresult;
if(string.IsNullOrWhiteSpace(region))
{
result=handle.Remove(key);
}
else
{
result=handle.Remove(key,region);
}

if(result)
{
handle.Stats.OnRemove(region);
}
}

privatevoidAddToHandles(CacheItem<TCacheValue>item,intfoundIndex)
{
if(_logTrace)
{
Logger.LogTrace(
"Start updating handles with [{0}].",
item);
}

if(foundIndex==0)
{
return;
}

// update all cache handles with lower order, up the list
for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<foundIndex)
{
if(_logTrace)
{
Logger.LogTrace("Updating handles, added [{0}] to handle '{1}'.",item,_cacheHandles[handleIndex].Configuration.Name);
}

_cacheHandles[handleIndex].Add(item);
}
}
}

privatevoidAddToHandlesBelow(CacheItem<TCacheValue>item,intfoundIndex)
{
if(item==null)
{
return;
}

if(_logTrace)
{
Logger.LogTrace("Add [{0}] to handles below handle '{1}'.",item,foundIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex>foundIndex)
{
if(_cacheHandles[handleIndex].Add(item))
{
_cacheHandles[handleIndex].Stats.OnAdd(item);
}
}
}
}

privatevoidEvictFromOtherHandles(stringkey,stringregion,intexcludeIndex)
{
if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

if(_logTrace)
{
Logger.LogTrace("Evict [{0}:{1}] from other handles excluding handle '{2}'.",region,key,excludeIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex!=excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidEvictFromHandlesAbove(stringkey,stringregion,intexcludeIndex)
{
if(_logTrace)
{
Logger.LogTrace("Evict from handles above: {0} {1}: above handle {2}.",key,region,excludeIndex);
}

if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidRegisterCacheBackplane(CacheBackplanebackplane)
{
NotNull(backplane,nameof(backplane));

// this should have been checked during activation already, just to be totally sure...
if(_cacheHandles.Any(p =>p.Configuration.IsBackplaneSource))
{
// added includeSource param to get the handles which need to be synced.
// in case the backplane source is non-distributed (in-memory), only remotely triggered remove and clear should also
// trigger a sync locally. For distributed caches, we expect that the distributed cache is already the source and in sync
// as that's the layer which triggered the event. In this case, only other in-memory handles above the distributed, would be synced.
varhandles=newFunc<bool,BaseCacheHandle<TCacheValue>[]>((includeSource)=>
{
varhandleList=newList<BaseCacheHandle<TCacheValue>>();
foreach(varhandlein_cacheHandles)
{
if(!handle.Configuration.IsBackplaneSource||
(includeSource&&handle.Configuration.IsBackplaneSource&&!handle.IsDistributedCache))
{
handleList.Add(handle);
}
}
returnhandleList.ToArray();
});

backplane.Changed+=(sender,args)=>
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Backplane event: [Changed] for '{1}:{0}'.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(false));
switch(args.Action)
{
caseCacheItemChangedEventAction.Add:
TriggerOnAdd(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Put:
TriggerOnPut(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Update:
TriggerOnUpdate(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;
}
};

backplane.Removed+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Remove] of {0} {1}.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(true));
TriggerOnRemove(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
};

backplane.Cleared+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear].");
}

ClearHandles(handles(true));
TriggerOnClear(CacheActionEventArgOrigin.Remote);
};

backplane.ClearedRegion+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear Region] region: {0}.",args.Region);
}

ClearRegionHandles(args.Region,handles(true));
TriggerOnClearRegion(args.Region,CacheActionEventArgOrigin.Remote);
};
}
}

privatevoidTriggerOnAdd(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnAdd?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnClear(CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClear?.Invoke(this,newCacheClearEventArgs(origin));
}

privatevoidTriggerOnClearRegion(stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClearRegion?.Invoke(this,newCacheClearRegionEventArgs(region,origin));
}

privatevoidTriggerOnGet(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnGet?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnPut(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnPut?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemove(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemove?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemoveByHandle(stringkey,stringregion,CacheItemRemovedReasonreason,intlevel,objectvalue)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemoveByHandle?.Invoke(this,newCacheItemRemovedEventArgs(key,region,reason,value,level));
}

privatevoidTriggerOnUpdate(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnUpdate?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}
}
}
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Globalization;
usingSystem.Linq;
usingCacheManager.Core.Internal;
usingMicrosoft.Extensions.Logging;
usingstaticCacheManager.Core.Utility.Guard;

namespaceCacheManager.Core
{
/// <summary>
/// The <see cref="BaseCacheManager{TCacheValue}"/> implements <see cref="ICacheManager{TCacheValue}"/> and is the main class
/// of this library.
/// The cache manager delegates all cache operations to the list of <see cref="BaseCacheHandle{T}"/>'s which have been
/// added. It will keep them in sync according to rules and depending on the configuration.
/// </summary>
/// <typeparam name="TCacheValue">The type of the cache value.</typeparam>
publicpartialclassBaseCacheManager<TCacheValue>:BaseCache<TCacheValue>,ICacheManager<TCacheValue>,IDisposable
{
privateclassNullLoggerFactory:ILoggerFactory
{
publicvoidAddProvider(ILoggerProviderprovider)
{
}

publicILoggerCreateLogger(stringcategoryName)
{
returnnewNullLogger();
}

publicvoidDispose()
{
}
}

privateclassNullLogger:ILogger<BaseCacheManager<TCacheValue>>
{
publicIDisposableBeginScope<TState>(TStatestate)=>null;

publicboolIsEnabled(LogLevellogLevel)=>false;

publicvoidLog<TState>(LogLevellogLevel,EventIdeventId,TStatestate,Exceptionexception,Func<TState,Exception,string>formatter)
{
// do nothing;
}
}

privatereadonlybool_logTrace=false;
privatereadonlyBaseCacheHandle<TCacheValue>[]_cacheHandles;
privatereadonlyCacheBackplane_cacheBackplane;

/// <summary>
/// Initializes a new instance of the <see cref="BaseCacheManager{TCacheValue}"/> class
/// using the specified <paramref name="configuration"/>.
/// If the name of the <paramref name="configuration"/> is defined, the cache manager will
/// use it. Otherwise a random string will be generated.
/// </summary>
/// <param name="configuration">
/// The configuration which defines the structure and complexity of the cache manager.
/// </param>
/// <param name="loggerFactory">Optional logger factory.</param>
/// <exception cref="System.ArgumentNullException">
/// When <paramref name="configuration"/> is null.
/// </exception>
/// <see cref="CacheFactory"/>
/// <see cref="CacheConfigurationBuilder"/>
/// <see cref="BaseCacheHandle{TCacheValue}"/>
publicBaseCacheManager(ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory=null)
:this(configuration?.Name??Guid.NewGuid().ToString(),configuration,loggerFactory??newNullLoggerFactory())
{
}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage","CA2200:RethrowToPreserveStackDetails",Justification="fine for now")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability","CA2000:Dispose objects before losing scope",Justification="nope")]
privateBaseCacheManager(stringname,ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory)
{
NotNullOrWhiteSpace(name,nameof(name));
NotNull(configuration,nameof(configuration));
NotNull(loggerFactory,nameof(loggerFactory));

Name=name;
Configuration=configuration;
varserializer=CacheReflectionHelper.CreateSerializer(configuration,loggerFactory);

Logger=loggerFactory.CreateLogger(this.GetType());

_logTrace=Logger.IsEnabled(LogLevel.Trace);

Logger.LogInformation("Cache manager: adding cache handles...");

try
{
_cacheHandles=CacheReflectionHelper.CreateCacheHandles(this,loggerFactory,serializer).ToArray();

varindex=0;
foreach(varhandlein_cacheHandles)
{
varhandleIndex=index;
handle.OnCacheSpecificRemove+=(sender,args)=>
{
// added sync for using backplane with in-memory caches on cache specific removal
// but commented for now, this is not really needed if all instances use the same expiration etc, would just cause duplicated events
////if (_cacheBackplane != null && handle.Configuration.IsBackplaneSource && !handle.IsDistributedCache)
////{
//// if (string.IsNullOrEmpty(args.Region))
//// {
//// _cacheBackplane.NotifyRemove(args.Key);
//// }
//// else
//// {
//// _cacheBackplane.NotifyRemove(args.Key, args.Region);
//// }
////}

// base cache handle does logging for this

if(Configuration.UpdateMode==CacheUpdateMode.Up)
{
if(_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.",handleIndex);
}

EvictFromHandlesAbove(args.Key,args.Region,handleIndex);
}

// moving down below cleanup, otherwise the item could still be in memory
TriggerOnRemoveByHandle(args.Key,args.Region,args.Reason,handleIndex+1,args.Value);
};

index++;
}

_cacheBackplane=CacheReflectionHelper.CreateBackplane(configuration,loggerFactory);
if(_cacheBackplane!=null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch(Exceptionex)
{
Logger.LogError(ex,"Error occurred while creating the cache manager.");
throwex.InnerException??ex;
}
}

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnAdd;

/// <inheritdoc />
publiceventEventHandler<CacheClearEventArgs>OnClear;

/// <inheritdoc />
publiceventEventHandler<CacheClearRegionEventArgs>OnClearRegion;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnGet;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnPut;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnRemove;

/// <inheritdoc />
publiceventEventHandler<CacheItemRemovedEventArgs>OnRemoveByHandle;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnUpdate;

/// <inheritdoc />
publicIReadOnlyCacheManagerConfigurationConfiguration{get;}

/// <inheritdoc />
publicIEnumerable<BaseCacheHandle<TCacheValue>>CacheHandles
=>newReadOnlyCollection<BaseCacheHandle<TCacheValue>>(
newList<BaseCacheHandle<TCacheValue>>(
_cacheHandles));

/// <summary>
/// Gets the configured cache backplane.
/// </summary>
/// <value>The backplane.</value>
publicCacheBackplaneBackplane=>_cacheBackplane;

/// <summary>
/// Gets the cache name.
/// </summary>
/// <value>The name of the cache.</value>
publicstringName{get;}

/// <inheritdoc />
protectedoverrideILoggerLogger{get;}

/// <inheritdoc />
publicoverridevoidClear()
{
CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear: flushing cache...");
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear: clearing handle {0}.",handle.Configuration.Name);
}

handle.Clear();
handle.Stats.OnClear();
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear: notifies backplane.");
}

_cacheBackplane.NotifyClear();
}

TriggerOnClear();
}

/// <inheritdoc />
publicoverridevoidClearRegion(stringregion)
{
NotNullOrWhiteSpace(region,nameof(region));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}.",region);
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0} in handle {1}.",region,handle.Configuration.Name);
}

handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}: notifies backplane [clear region].",region);
}

_cacheBackplane.NotifyClearRegion(region);
}

TriggerOnClearRegion(region);
}

/// <inheritdoc />
publicoverrideboolExists(stringkey)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}] exists on handle '{1}'.",key,handle.Configuration.Name);
}

if(handle.Exists(key))
{
returntrue;
}
}

returnfalse;
}

/// <inheritdoc />
publicoverrideboolExists(stringkey,stringregion)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}:{1}] exists on handle '{2}'.",region,key,handle.Configuration.Name);
}

if(handle.Exists(key,region))
{
returntrue;
}
}

returnfalse;
}

/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
publicoverridestringToString()=>
string.Format(CultureInfo.InvariantCulture,"Name: {0}, Handles: [{1}]",Name,string.Join(",",_cacheHandles.Select(p =>p.GetType().Name)));

/// <inheritdoc />
protectedinternaloverrideboolAddInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Add [{0}] started.",item);
}

varhandleIndex=_cacheHandles.Length-1;

varresult=AddItemToHandle(item,_cacheHandles[handleIndex]);

// evict from other handles in any case because if it exists, it might be a different version
// if not exist, its just a sanity check to invalidate other versions in upper layers.
EvictFromOtherHandles(item.Key,item.Region,handleIndex);

if(result)
{
// update backplane
if(_cacheBackplane!=null)
{
if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Add);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Add);
}

if(_logTrace)
{
Logger.LogTrace("Notified backplane 'change' because [{0}] was added.",item);
}
}

// trigger only once and not per handle and only if the item was added!
TriggerOnAdd(item.Key,item.Region);
}

returnresult;
}

/// <inheritdoc />
protectedinternaloverridevoidPutInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Put [{0}] started.",item);
}

foreach(varhandlein_cacheHandles)
{
if(handle.Configuration.EnableStatistics)
{
// check if it is really a new item otherwise the items count is crap because we
// count it every time, but use only the current handle to retrieve the item,
// otherwise we would trigger gets and find it in another handle maybe
varoldItem=string.IsNullOrWhiteSpace(item.Region)?
handle.GetCacheItem(item.Key):
handle.GetCacheItem(item.Key,item.Region);

handle.Stats.OnPut(item,oldItem==null);
}

if(_logTrace)
{
Logger.LogTrace(
"Put [{0}:{1}] successfully to handle '{2}'.",
item.Region,
item.Key,
handle.Configuration.Name);
}

handle.Put(item);
}

// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Put [{0}:{1}] was scuccessful. Notifying backplane [change].",item.Region,item.Key);
}

if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Put);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Put);
}
}

TriggerOnPut(item.Key,item.Region);
}

/// <inheritdoc />
protectedoverridevoidDispose(booldisposeManaged)
{
if(disposeManaged)
{
foreach(varhandlein_cacheHandles)
{
handle.Dispose();
}

if(_cacheBackplane!=null)
{
_cacheBackplane.Dispose();
}
}

base.Dispose(disposeManaged);
}

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey)=>
GetCacheItemInternal(key,null);

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey,stringregion)
{
CheckDisposed();

CacheItem<TCacheValue>cacheItem=null;

if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}] started.",region,key);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
varhandle=_cacheHandles[handleIndex];
if(string.IsNullOrWhiteSpace(region))
{
cacheItem=handle.GetCacheItem(key);
}
else
{
cacheItem=handle.GetCacheItem(key,region);
}

handle.Stats.OnGet(region);

if(cacheItem!=null)
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

// update last accessed, might be used for custom sliding implementations
cacheItem.LastAccessedUtc=DateTime.UtcNow;

// update other handles if needed
AddToHandles(cacheItem,handleIndex);
handle.Stats.OnHit(region);
TriggerOnGet(key,region);
break;
}
else
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], item NOT found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

handle.Stats.OnMiss(region);
}
}

returncacheItem;
}

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey)=>
RemoveInternal(key,null);

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey,stringregion)
{
CheckDisposed();

varresult=false;

if(_logTrace)
{
Logger.LogTrace("Removing [{0}:{1}].",region,key);
}

foreach(varhandlein_cacheHandles)
{
varhandleResult=false;
if(!string.IsNullOrWhiteSpace(region))
{
handleResult=handle.Remove(key,region);
}
else
{
handleResult=handle.Remove(key);
}

if(handleResult)
{
if(_logTrace)
{
Logger.LogTrace(
"Remove [{0}:{1}], successfully removed from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

result=true;
handle.Stats.OnRemove(region);
}
}

// See #311, send remove events anyways if the backlane is configured but no distributed cache is used.
varinProcOnly=_cacheHandles.Any(p =>!p.IsDistributedCache);

if(result||inProcOnly)
{
// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Removed [{0}:{1}], notifying backplane [remove].",region,key);
}

if(string.IsNullOrWhiteSpace(region))
{
_cacheBackplane.NotifyRemove(key);
}
else
{
_cacheBackplane.NotifyRemove(key,region);
}
}

if(result)
{
// trigger only once and not per handle
TriggerOnRemove(key,region);
}
}

returnresult;
}

privatestaticboolAddItemToHandle(CacheItem<TCacheValue>item,BaseCacheHandle<TCacheValue>handle)
{
if(handle.Add(item))
{
handle.Stats.OnAdd(item);
returntrue;
}

returnfalse;
}

privatestaticvoidClearHandles(BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.Clear();
handle.Stats.OnClear();
}

////this.TriggerOnClear();
}

privatestaticvoidClearRegionHandles(stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

////this.TriggerOnClearRegion(region);
}

privatevoidEvictFromHandles(stringkey,stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
EvictFromHandle(key,region,handle);
}
}

privatevoidEvictFromHandle(stringkey,stringregion,BaseCacheHandle<TCacheValue>handle)
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug(
"Evicting '{0}:{1}' from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

boolresult;
if(string.IsNullOrWhiteSpace(region))
{
result=handle.Remove(key);
}
else
{
result=handle.Remove(key,region);
}

if(result)
{
handle.Stats.OnRemove(region);
}
}

privatevoidAddToHandles(CacheItem<TCacheValue>item,intfoundIndex)
{
if(_logTrace)
{
Logger.LogTrace(
"Start updating handles with [{0}].",
item);
}

if(foundIndex==0)
{
return;
}

// update all cache handles with lower order, up the list
for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<foundIndex)
{
if(_logTrace)
{
Logger.LogTrace("Updating handles, added [{0}] to handle '{1}'.",item,_cacheHandles[handleIndex].Configuration.Name);
}

_cacheHandles[handleIndex].Add(item);
}
}
}

privatevoidAddToHandlesBelow(CacheItem<TCacheValue>item,intfoundIndex)
{
if(item==null)
{
return;
}

if(_logTrace)
{
Logger.LogTrace("Add [{0}] to handles below handle '{1}'.",item,foundIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex>foundIndex)
{
if(_cacheHandles[handleIndex].Add(item))
{
_cacheHandles[handleIndex].Stats.OnAdd(item);
}
}
}
}

privatevoidEvictFromOtherHandles(stringkey,stringregion,intexcludeIndex)
{
if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

if(_logTrace)
{
Logger.LogTrace("Evict [{0}:{1}] from other handles excluding handle '{2}'.",region,key,excludeIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex!=excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidEvictFromHandlesAbove(stringkey,stringregion,intexcludeIndex)
{
if(_logTrace)
{
Logger.LogTrace("Evict from handles above: {0} {1}: above handle {2}.",key,region,excludeIndex);
}

if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidRegisterCacheBackplane(CacheBackplanebackplane)
{
NotNull(backplane,nameof(backplane));

// this should have been checked during activation already, just to be totally sure...
if(_cacheHandles.Any(p =>p.Configuration.IsBackplaneSource))
{
// added includeSource param to get the handles which need to be synced.
// in case the backplane source is non-distributed (in-memory), only remotely triggered remove and clear should also
// trigger a sync locally. For distributed caches, we expect that the distributed cache is already the source and in sync
// as that's the layer which triggered the event. In this case, only other in-memory handles above the distributed, would be synced.
varhandles=newFunc<bool,BaseCacheHandle<TCacheValue>[]>((includeSource)=>
{
varhandleList=newList<BaseCacheHandle<TCacheValue>>();
foreach(varhandlein_cacheHandles)
{
if(!handle.Configuration.IsBackplaneSource||
(includeSource&&handle.Configuration.IsBackplaneSource&&!handle.IsDistributedCache))
{
handleList.Add(handle);
}
}
returnhandleList.ToArray();
});

backplane.Changed+=(sender,args)=>
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Backplane event: [Changed] for '{1}:{0}'.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(false));
switch(args.Action)
{
caseCacheItemChangedEventAction.Add:
TriggerOnAdd(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Put:
TriggerOnPut(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Update:
TriggerOnUpdate(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;
}
};

backplane.Removed+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Remove] of {0} {1}.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(true));
TriggerOnRemove(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
};

backplane.Cleared+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear].");
}

ClearHandles(handles(true));
TriggerOnClear(CacheActionEventArgOrigin.Remote);
};

backplane.ClearedRegion+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear Region] region: {0}.",args.Region);
}

ClearRegionHandles(args.Region,handles(true));
TriggerOnClearRegion(args.Region,CacheActionEventArgOrigin.Remote);
};
}
}

privatevoidTriggerOnAdd(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnAdd?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnClear(CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClear?.Invoke(this,newCacheClearEventArgs(origin));
}

privatevoidTriggerOnClearRegion(stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClearRegion?.Invoke(this,newCacheClearRegionEventArgs(region,origin));
}

privatevoidTriggerOnGet(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnGet?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnPut(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnPut?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemove(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemove?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemoveByHandle(stringkey,stringregion,CacheItemRemovedReasonreason,intlevel,objectvalue)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemoveByHandle?.Invoke(this,newCacheItemRemovedEventArgs(key,region,reason,value,level));
}

privatevoidTriggerOnUpdate(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnUpdate?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}
}
}
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Globalization;
usingSystem.Linq;
usingCacheManager.Core.Internal;
usingMicrosoft.Extensions.Logging;
usingstaticCacheManager.Core.Utility.Guard;

namespaceCacheManager.Core
{
/// <summary>
/// The <see cref="BaseCacheManager{TCacheValue}"/> implements <see cref="ICacheManager{TCacheValue}"/> and is the main class
/// of this library.
/// The cache manager delegates all cache operations to the list of <see cref="BaseCacheHandle{T}"/>'s which have been
/// added. It will keep them in sync according to rules and depending on the configuration.
/// </summary>
/// <typeparam name="TCacheValue">The type of the cache value.</typeparam>
publicpartialclassBaseCacheManager<TCacheValue>:BaseCache<TCacheValue>,ICacheManager<TCacheValue>,IDisposable
{
privateclassNullLoggerFactory:ILoggerFactory
{
publicvoidAddProvider(ILoggerProviderprovider)
{
}

publicILoggerCreateLogger(stringcategoryName)
{
returnnewNullLogger();
}

publicvoidDispose()
{
}
}

privateclassNullLogger:ILogger<BaseCacheManager<TCacheValue>>
{
publicIDisposableBeginScope<TState>(TStatestate)=>null;

publicboolIsEnabled(LogLevellogLevel)=>false;

publicvoidLog<TState>(LogLevellogLevel,EventIdeventId,TStatestate,Exceptionexception,Func<TState,Exception,string>formatter)
{
// do nothing;
}
}

privatereadonlybool_logTrace=false;
privatereadonlyBaseCacheHandle<TCacheValue>[]_cacheHandles;
privatereadonlyCacheBackplane_cacheBackplane;

/// <summary>
/// Initializes a new instance of the <see cref="BaseCacheManager{TCacheValue}"/> class
/// using the specified <paramref name="configuration"/>.
/// If the name of the <paramref name="configuration"/> is defined, the cache manager will
/// use it. Otherwise a random string will be generated.
/// </summary>
/// <param name="configuration">
/// The configuration which defines the structure and complexity of the cache manager.
/// </param>
/// <param name="loggerFactory">Optional logger factory.</param>
/// <exception cref="System.ArgumentNullException">
/// When <paramref name="configuration"/> is null.
/// </exception>
/// <see cref="CacheFactory"/>
/// <see cref="CacheConfigurationBuilder"/>
/// <see cref="BaseCacheHandle{TCacheValue}"/>
publicBaseCacheManager(ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory=null)
:this(configuration?.Name??Guid.NewGuid().ToString(),configuration,loggerFactory??newNullLoggerFactory())
{
}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage","CA2200:RethrowToPreserveStackDetails",Justification="fine for now")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability","CA2000:Dispose objects before losing scope",Justification="nope")]
privateBaseCacheManager(stringname,ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory)
{
NotNullOrWhiteSpace(name,nameof(name));
NotNull(configuration,nameof(configuration));
NotNull(loggerFactory,nameof(loggerFactory));

Name=name;
Configuration=configuration;
varserializer=CacheReflectionHelper.CreateSerializer(configuration,loggerFactory);

Logger=loggerFactory.CreateLogger(this.GetType());

_logTrace=Logger.IsEnabled(LogLevel.Trace);

Logger.LogInformation("Cache manager: adding cache handles...");

try
{
_cacheHandles=CacheReflectionHelper.CreateCacheHandles(this,loggerFactory,serializer).ToArray();

varindex=0;
foreach(varhandlein_cacheHandles)
{
varhandleIndex=index;
handle.OnCacheSpecificRemove+=(sender,args)=>
{
// added sync for using backplane with in-memory caches on cache specific removal
// but commented for now, this is not really needed if all instances use the same expiration etc, would just cause duplicated events
////if (_cacheBackplane != null && handle.Configuration.IsBackplaneSource && !handle.IsDistributedCache)
////{
//// if (string.IsNullOrEmpty(args.Region))
//// {
//// _cacheBackplane.NotifyRemove(args.Key);
//// }
//// else
//// {
//// _cacheBackplane.NotifyRemove(args.Key, args.Region);
//// }
////}

// base cache handle does logging for this

if(Configuration.UpdateMode==CacheUpdateMode.Up)
{
if(_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.",handleIndex);
}

EvictFromHandlesAbove(args.Key,args.Region,handleIndex);
}

// moving down below cleanup, otherwise the item could still be in memory
TriggerOnRemoveByHandle(args.Key,args.Region,args.Reason,handleIndex+1,args.Value);
};

index++;
}

_cacheBackplane=CacheReflectionHelper.CreateBackplane(configuration,loggerFactory);
if(_cacheBackplane!=null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch(Exceptionex)
{
Logger.LogError(ex,"Error occurred while creating the cache manager.");
throwex.InnerException??ex;
}
}

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnAdd;

/// <inheritdoc />
publiceventEventHandler<CacheClearEventArgs>OnClear;

/// <inheritdoc />
publiceventEventHandler<CacheClearRegionEventArgs>OnClearRegion;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnGet;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnPut;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnRemove;

/// <inheritdoc />
publiceventEventHandler<CacheItemRemovedEventArgs>OnRemoveByHandle;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnUpdate;

/// <inheritdoc />
publicIReadOnlyCacheManagerConfigurationConfiguration{get;}

/// <inheritdoc />
publicIEnumerable<BaseCacheHandle<TCacheValue>>CacheHandles
=>newReadOnlyCollection<BaseCacheHandle<TCacheValue>>(
newList<BaseCacheHandle<TCacheValue>>(
_cacheHandles));

/// <summary>
/// Gets the configured cache backplane.
/// </summary>
/// <value>The backplane.</value>
publicCacheBackplaneBackplane=>_cacheBackplane;

/// <summary>
/// Gets the cache name.
/// </summary>
/// <value>The name of the cache.</value>
publicstringName{get;}

/// <inheritdoc />
protectedoverrideILoggerLogger{get;}

/// <inheritdoc />
publicoverridevoidClear()
{
CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear: flushing cache...");
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear: clearing handle {0}.",handle.Configuration.Name);
}

handle.Clear();
handle.Stats.OnClear();
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear: notifies backplane.");
}

_cacheBackplane.NotifyClear();
}

TriggerOnClear();
}

/// <inheritdoc />
publicoverridevoidClearRegion(stringregion)
{
NotNullOrWhiteSpace(region,nameof(region));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}.",region);
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0} in handle {1}.",region,handle.Configuration.Name);
}

handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}: notifies backplane [clear region].",region);
}

_cacheBackplane.NotifyClearRegion(region);
}

TriggerOnClearRegion(region);
}

/// <inheritdoc />
publicoverrideboolExists(stringkey)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}] exists on handle '{1}'.",key,handle.Configuration.Name);
}

if(handle.Exists(key))
{
returntrue;
}
}

returnfalse;
}

/// <inheritdoc />
publicoverrideboolExists(stringkey,stringregion)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}:{1}] exists on handle '{2}'.",region,key,handle.Configuration.Name);
}

if(handle.Exists(key,region))
{
returntrue;
}
}

returnfalse;
}

/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
publicoverridestringToString()=>
string.Format(CultureInfo.InvariantCulture,"Name: {0}, Handles: [{1}]",Name,string.Join(",",_cacheHandles.Select(p =>p.GetType().Name)));

/// <inheritdoc />
protectedinternaloverrideboolAddInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Add [{0}] started.",item);
}

varhandleIndex=_cacheHandles.Length-1;

varresult=AddItemToHandle(item,_cacheHandles[handleIndex]);

// evict from other handles in any case because if it exists, it might be a different version
// if not exist, its just a sanity check to invalidate other versions in upper layers.
EvictFromOtherHandles(item.Key,item.Region,handleIndex);

if(result)
{
// update backplane
if(_cacheBackplane!=null)
{
if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Add);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Add);
}

if(_logTrace)
{
Logger.LogTrace("Notified backplane 'change' because [{0}] was added.",item);
}
}

// trigger only once and not per handle and only if the item was added!
TriggerOnAdd(item.Key,item.Region);
}

returnresult;
}

/// <inheritdoc />
protectedinternaloverridevoidPutInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Put [{0}] started.",item);
}

foreach(varhandlein_cacheHandles)
{
if(handle.Configuration.EnableStatistics)
{
// check if it is really a new item otherwise the items count is crap because we
// count it every time, but use only the current handle to retrieve the item,
// otherwise we would trigger gets and find it in another handle maybe
varoldItem=string.IsNullOrWhiteSpace(item.Region)?
handle.GetCacheItem(item.Key):
handle.GetCacheItem(item.Key,item.Region);

handle.Stats.OnPut(item,oldItem==null);
}

if(_logTrace)
{
Logger.LogTrace(
"Put [{0}:{1}] successfully to handle '{2}'.",
item.Region,
item.Key,
handle.Configuration.Name);
}

handle.Put(item);
}

// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Put [{0}:{1}] was scuccessful. Notifying backplane [change].",item.Region,item.Key);
}

if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Put);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Put);
}
}

TriggerOnPut(item.Key,item.Region);
}

/// <inheritdoc />
protectedoverridevoidDispose(booldisposeManaged)
{
if(disposeManaged)
{
foreach(varhandlein_cacheHandles)
{
handle.Dispose();
}

if(_cacheBackplane!=null)
{
_cacheBackplane.Dispose();
}
}

base.Dispose(disposeManaged);
}

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey)=>
GetCacheItemInternal(key,null);

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey,stringregion)
{
CheckDisposed();

CacheItem<TCacheValue>cacheItem=null;

if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}] started.",region,key);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
varhandle=_cacheHandles[handleIndex];
if(string.IsNullOrWhiteSpace(region))
{
cacheItem=handle.GetCacheItem(key);
}
else
{
cacheItem=handle.GetCacheItem(key,region);
}

handle.Stats.OnGet(region);

if(cacheItem!=null)
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

// update last accessed, might be used for custom sliding implementations
cacheItem.LastAccessedUtc=DateTime.UtcNow;

// update other handles if needed
AddToHandles(cacheItem,handleIndex);
handle.Stats.OnHit(region);
TriggerOnGet(key,region);
break;
}
else
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], item NOT found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

handle.Stats.OnMiss(region);
}
}

returncacheItem;
}

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey)=>
RemoveInternal(key,null);

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey,stringregion)
{
CheckDisposed();

varresult=false;

if(_logTrace)
{
Logger.LogTrace("Removing [{0}:{1}].",region,key);
}

foreach(varhandlein_cacheHandles)
{
varhandleResult=false;
if(!string.IsNullOrWhiteSpace(region))
{
handleResult=handle.Remove(key,region);
}
else
{
handleResult=handle.Remove(key);
}

if(handleResult)
{
if(_logTrace)
{
Logger.LogTrace(
"Remove [{0}:{1}], successfully removed from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

result=true;
handle.Stats.OnRemove(region);
}
}

// See #311, send remove events anyways if the backlane is configured but no distributed cache is used.
varinProcOnly=_cacheHandles.Any(p =>!p.IsDistributedCache);

if(result||inProcOnly)
{
// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Removed [{0}:{1}], notifying backplane [remove].",region,key);
}

if(string.IsNullOrWhiteSpace(region))
{
_cacheBackplane.NotifyRemove(key);
}
else
{
_cacheBackplane.NotifyRemove(key,region);
}
}

if(result)
{
// trigger only once and not per handle
TriggerOnRemove(key,region);
}
}

returnresult;
}

privatestaticboolAddItemToHandle(CacheItem<TCacheValue>item,BaseCacheHandle<TCacheValue>handle)
{
if(handle.Add(item))
{
handle.Stats.OnAdd(item);
returntrue;
}

returnfalse;
}

privatestaticvoidClearHandles(BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.Clear();
handle.Stats.OnClear();
}

////this.TriggerOnClear();
}

privatestaticvoidClearRegionHandles(stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

////this.TriggerOnClearRegion(region);
}

privatevoidEvictFromHandles(stringkey,stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
EvictFromHandle(key,region,handle);
}
}

privatevoidEvictFromHandle(stringkey,stringregion,BaseCacheHandle<TCacheValue>handle)
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug(
"Evicting '{0}:{1}' from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

boolresult;
if(string.IsNullOrWhiteSpace(region))
{
result=handle.Remove(key);
}
else
{
result=handle.Remove(key,region);
}

if(result)
{
handle.Stats.OnRemove(region);
}
}

privatevoidAddToHandles(CacheItem<TCacheValue>item,intfoundIndex)
{
if(_logTrace)
{
Logger.LogTrace(
"Start updating handles with [{0}].",
item);
}

if(foundIndex==0)
{
return;
}

// update all cache handles with lower order, up the list
for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<foundIndex)
{
if(_logTrace)
{
Logger.LogTrace("Updating handles, added [{0}] to handle '{1}'.",item,_cacheHandles[handleIndex].Configuration.Name);
}

_cacheHandles[handleIndex].Add(item);
}
}
}

privatevoidAddToHandlesBelow(CacheItem<TCacheValue>item,intfoundIndex)
{
if(item==null)
{
return;
}

if(_logTrace)
{
Logger.LogTrace("Add [{0}] to handles below handle '{1}'.",item,foundIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex>foundIndex)
{
if(_cacheHandles[handleIndex].Add(item))
{
_cacheHandles[handleIndex].Stats.OnAdd(item);
}
}
}
}

privatevoidEvictFromOtherHandles(stringkey,stringregion,intexcludeIndex)
{
if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

if(_logTrace)
{
Logger.LogTrace("Evict [{0}:{1}] from other handles excluding handle '{2}'.",region,key,excludeIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex!=excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidEvictFromHandlesAbove(stringkey,stringregion,intexcludeIndex)
{
if(_logTrace)
{
Logger.LogTrace("Evict from handles above: {0} {1}: above handle {2}.",key,region,excludeIndex);
}

if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidRegisterCacheBackplane(CacheBackplanebackplane)
{
NotNull(backplane,nameof(backplane));

// this should have been checked during activation already, just to be totally sure...
if(_cacheHandles.Any(p =>p.Configuration.IsBackplaneSource))
{
// added includeSource param to get the handles which need to be synced.
// in case the backplane source is non-distributed (in-memory), only remotely triggered remove and clear should also
// trigger a sync locally. For distributed caches, we expect that the distributed cache is already the source and in sync
// as that's the layer which triggered the event. In this case, only other in-memory handles above the distributed, would be synced.
varhandles=newFunc<bool,BaseCacheHandle<TCacheValue>[]>((includeSource)=>
{
varhandleList=newList<BaseCacheHandle<TCacheValue>>();
foreach(varhandlein_cacheHandles)
{
if(!handle.Configuration.IsBackplaneSource||
(includeSource&&handle.Configuration.IsBackplaneSource&&!handle.IsDistributedCache))
{
handleList.Add(handle);
}
}
returnhandleList.ToArray();
});

backplane.Changed+=(sender,args)=>
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Backplane event: [Changed] for '{1}:{0}'.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(false));
switch(args.Action)
{
caseCacheItemChangedEventAction.Add:
TriggerOnAdd(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Put:
TriggerOnPut(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Update:
TriggerOnUpdate(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;
}
};

backplane.Removed+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Remove] of {0} {1}.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(true));
TriggerOnRemove(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
};

backplane.Cleared+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear].");
}

ClearHandles(handles(true));
TriggerOnClear(CacheActionEventArgOrigin.Remote);
};

backplane.ClearedRegion+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear Region] region: {0}.",args.Region);
}

ClearRegionHandles(args.Region,handles(true));
TriggerOnClearRegion(args.Region,CacheActionEventArgOrigin.Remote);
};
}
}

privatevoidTriggerOnAdd(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnAdd?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnClear(CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClear?.Invoke(this,newCacheClearEventArgs(origin));
}

privatevoidTriggerOnClearRegion(stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClearRegion?.Invoke(this,newCacheClearRegionEventArgs(region,origin));
}

privatevoidTriggerOnGet(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnGet?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnPut(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnPut?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemove(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemove?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemoveByHandle(stringkey,stringregion,CacheItemRemovedReasonreason,intlevel,objectvalue)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemoveByHandle?.Invoke(this,newCacheItemRemovedEventArgs(key,region,reason,value,level));
}

privatevoidTriggerOnUpdate(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnUpdate?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}
}
}
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Globalization;
usingSystem.Linq;
usingCacheManager.Core.Internal;
usingMicrosoft.Extensions.Logging;
usingstaticCacheManager.Core.Utility.Guard;

namespaceCacheManager.Core
{
/// <summary>
/// The <see cref="BaseCacheManager{TCacheValue}"/> implements <see cref="ICacheManager{TCacheValue}"/> and is the main class
/// of this library.
/// The cache manager delegates all cache operations to the list of <see cref="BaseCacheHandle{T}"/>'s which have been
/// added. It will keep them in sync according to rules and depending on the configuration.
/// </summary>
/// <typeparam name="TCacheValue">The type of the cache value.</typeparam>
publicpartialclassBaseCacheManager<TCacheValue>:BaseCache<TCacheValue>,ICacheManager<TCacheValue>,IDisposable
{
privateclassNullLoggerFactory:ILoggerFactory
{
publicvoidAddProvider(ILoggerProviderprovider)
{
}

publicILoggerCreateLogger(stringcategoryName)
{
returnnewNullLogger();
}

publicvoidDispose()
{
}
}

privateclassNullLogger:ILogger<BaseCacheManager<TCacheValue>>
{
publicIDisposableBeginScope<TState>(TStatestate)=>null;

publicboolIsEnabled(LogLevellogLevel)=>false;

publicvoidLog<TState>(LogLevellogLevel,EventIdeventId,TStatestate,Exceptionexception,Func<TState,Exception,string>formatter)
{
// do nothing;
}
}

privatereadonlybool_logTrace=false;
privatereadonlyBaseCacheHandle<TCacheValue>[]_cacheHandles;
privatereadonlyCacheBackplane_cacheBackplane;

/// <summary>
/// Initializes a new instance of the <see cref="BaseCacheManager{TCacheValue}"/> class
/// using the specified <paramref name="configuration"/>.
/// If the name of the <paramref name="configuration"/> is defined, the cache manager will
/// use it. Otherwise a random string will be generated.
/// </summary>
/// <param name="configuration">
/// The configuration which defines the structure and complexity of the cache manager.
/// </param>
/// <param name="loggerFactory">Optional logger factory.</param>
/// <exception cref="System.ArgumentNullException">
/// When <paramref name="configuration"/> is null.
/// </exception>
/// <see cref="CacheFactory"/>
/// <see cref="CacheConfigurationBuilder"/>
/// <see cref="BaseCacheHandle{TCacheValue}"/>
publicBaseCacheManager(ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory=null)
:this(configuration?.Name??Guid.NewGuid().ToString(),configuration,loggerFactory??newNullLoggerFactory())
{
}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage","CA2200:RethrowToPreserveStackDetails",Justification="fine for now")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability","CA2000:Dispose objects before losing scope",Justification="nope")]
privateBaseCacheManager(stringname,ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory)
{
NotNullOrWhiteSpace(name,nameof(name));
NotNull(configuration,nameof(configuration));
NotNull(loggerFactory,nameof(loggerFactory));

Name=name;
Configuration=configuration;
varserializer=CacheReflectionHelper.CreateSerializer(configuration,loggerFactory);

Logger=loggerFactory.CreateLogger(this.GetType());

_logTrace=Logger.IsEnabled(LogLevel.Trace);

Logger.LogInformation("Cache manager: adding cache handles...");

try
{
_cacheHandles=CacheReflectionHelper.CreateCacheHandles(this,loggerFactory,serializer).ToArray();

varindex=0;
foreach(varhandlein_cacheHandles)
{
varhandleIndex=index;
handle.OnCacheSpecificRemove+=(sender,args)=>
{
// added sync for using backplane with in-memory caches on cache specific removal
// but commented for now, this is not really needed if all instances use the same expiration etc, would just cause duplicated events
////if (_cacheBackplane != null && handle.Configuration.IsBackplaneSource && !handle.IsDistributedCache)
////{
//// if (string.IsNullOrEmpty(args.Region))
//// {
//// _cacheBackplane.NotifyRemove(args.Key);
//// }
//// else
//// {
//// _cacheBackplane.NotifyRemove(args.Key, args.Region);
//// }
////}

// base cache handle does logging for this

if(Configuration.UpdateMode==CacheUpdateMode.Up)
{
if(_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.",handleIndex);
}

EvictFromHandlesAbove(args.Key,args.Region,handleIndex);
}

// moving down below cleanup, otherwise the item could still be in memory
TriggerOnRemoveByHandle(args.Key,args.Region,args.Reason,handleIndex+1,args.Value);
};

index++;
}

_cacheBackplane=CacheReflectionHelper.CreateBackplane(configuration,loggerFactory);
if(_cacheBackplane!=null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch(Exceptionex)
{
Logger.LogError(ex,"Error occurred while creating the cache manager.");
throwex.InnerException??ex;
}
}

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnAdd;

/// <inheritdoc />
publiceventEventHandler<CacheClearEventArgs>OnClear;

/// <inheritdoc />
publiceventEventHandler<CacheClearRegionEventArgs>OnClearRegion;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnGet;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnPut;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnRemove;

/// <inheritdoc />
publiceventEventHandler<CacheItemRemovedEventArgs>OnRemoveByHandle;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnUpdate;

/// <inheritdoc />
publicIReadOnlyCacheManagerConfigurationConfiguration{get;}

/// <inheritdoc />
publicIEnumerable<BaseCacheHandle<TCacheValue>>CacheHandles
=>newReadOnlyCollection<BaseCacheHandle<TCacheValue>>(
newList<BaseCacheHandle<TCacheValue>>(
_cacheHandles));

/// <summary>
/// Gets the configured cache backplane.
/// </summary>
/// <value>The backplane.</value>
publicCacheBackplaneBackplane=>_cacheBackplane;

/// <summary>
/// Gets the cache name.
/// </summary>
/// <value>The name of the cache.</value>
publicstringName{get;}

/// <inheritdoc />
protectedoverrideILoggerLogger{get;}

/// <inheritdoc />
publicoverridevoidClear()
{
CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear: flushing cache...");
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear: clearing handle {0}.",handle.Configuration.Name);
}

handle.Clear();
handle.Stats.OnClear();
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear: notifies backplane.");
}

_cacheBackplane.NotifyClear();
}

TriggerOnClear();
}

/// <inheritdoc />
publicoverridevoidClearRegion(stringregion)
{
NotNullOrWhiteSpace(region,nameof(region));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}.",region);
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0} in handle {1}.",region,handle.Configuration.Name);
}

handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}: notifies backplane [clear region].",region);
}

_cacheBackplane.NotifyClearRegion(region);
}

TriggerOnClearRegion(region);
}

/// <inheritdoc />
publicoverrideboolExists(stringkey)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}] exists on handle '{1}'.",key,handle.Configuration.Name);
}

if(handle.Exists(key))
{
returntrue;
}
}

returnfalse;
}

/// <inheritdoc />
publicoverrideboolExists(stringkey,stringregion)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}:{1}] exists on handle '{2}'.",region,key,handle.Configuration.Name);
}

if(handle.Exists(key,region))
{
returntrue;
}
}

returnfalse;
}

/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
publicoverridestringToString()=>
string.Format(CultureInfo.InvariantCulture,"Name: {0}, Handles: [{1}]",Name,string.Join(",",_cacheHandles.Select(p =>p.GetType().Name)));

/// <inheritdoc />
protectedinternaloverrideboolAddInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Add [{0}] started.",item);
}

varhandleIndex=_cacheHandles.Length-1;

varresult=AddItemToHandle(item,_cacheHandles[handleIndex]);

// evict from other handles in any case because if it exists, it might be a different version
// if not exist, its just a sanity check to invalidate other versions in upper layers.
EvictFromOtherHandles(item.Key,item.Region,handleIndex);

if(result)
{
// update backplane
if(_cacheBackplane!=null)
{
if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Add);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Add);
}

if(_logTrace)
{
Logger.LogTrace("Notified backplane 'change' because [{0}] was added.",item);
}
}

// trigger only once and not per handle and only if the item was added!
TriggerOnAdd(item.Key,item.Region);
}

returnresult;
}

/// <inheritdoc />
protectedinternaloverridevoidPutInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Put [{0}] started.",item);
}

foreach(varhandlein_cacheHandles)
{
if(handle.Configuration.EnableStatistics)
{
// check if it is really a new item otherwise the items count is crap because we
// count it every time, but use only the current handle to retrieve the item,
// otherwise we would trigger gets and find it in another handle maybe
varoldItem=string.IsNullOrWhiteSpace(item.Region)?
handle.GetCacheItem(item.Key):
handle.GetCacheItem(item.Key,item.Region);

handle.Stats.OnPut(item,oldItem==null);
}

if(_logTrace)
{
Logger.LogTrace(
"Put [{0}:{1}] successfully to handle '{2}'.",
item.Region,
item.Key,
handle.Configuration.Name);
}

handle.Put(item);
}

// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Put [{0}:{1}] was scuccessful. Notifying backplane [change].",item.Region,item.Key);
}

if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Put);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Put);
}
}

TriggerOnPut(item.Key,item.Region);
}

/// <inheritdoc />
protectedoverridevoidDispose(booldisposeManaged)
{
if(disposeManaged)
{
foreach(varhandlein_cacheHandles)
{
handle.Dispose();
}

if(_cacheBackplane!=null)
{
_cacheBackplane.Dispose();
}
}

base.Dispose(disposeManaged);
}

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey)=>
GetCacheItemInternal(key,null);

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey,stringregion)
{
CheckDisposed();

CacheItem<TCacheValue>cacheItem=null;

if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}] started.",region,key);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
varhandle=_cacheHandles[handleIndex];
if(string.IsNullOrWhiteSpace(region))
{
cacheItem=handle.GetCacheItem(key);
}
else
{
cacheItem=handle.GetCacheItem(key,region);
}

handle.Stats.OnGet(region);

if(cacheItem!=null)
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

// update last accessed, might be used for custom sliding implementations
cacheItem.LastAccessedUtc=DateTime.UtcNow;

// update other handles if needed
AddToHandles(cacheItem,handleIndex);
handle.Stats.OnHit(region);
TriggerOnGet(key,region);
break;
}
else
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], item NOT found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

handle.Stats.OnMiss(region);
}
}

returncacheItem;
}

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey)=>
RemoveInternal(key,null);

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey,stringregion)
{
CheckDisposed();

varresult=false;

if(_logTrace)
{
Logger.LogTrace("Removing [{0}:{1}].",region,key);
}

foreach(varhandlein_cacheHandles)
{
varhandleResult=false;
if(!string.IsNullOrWhiteSpace(region))
{
handleResult=handle.Remove(key,region);
}
else
{
handleResult=handle.Remove(key);
}

if(handleResult)
{
if(_logTrace)
{
Logger.LogTrace(
"Remove [{0}:{1}], successfully removed from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

result=true;
handle.Stats.OnRemove(region);
}
}

// See #311, send remove events anyways if the backlane is configured but no distributed cache is used.
varinProcOnly=_cacheHandles.Any(p =>!p.IsDistributedCache);

if(result||inProcOnly)
{
// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Removed [{0}:{1}], notifying backplane [remove].",region,key);
}

if(string.IsNullOrWhiteSpace(region))
{
_cacheBackplane.NotifyRemove(key);
}
else
{
_cacheBackplane.NotifyRemove(key,region);
}
}

if(result)
{
// trigger only once and not per handle
TriggerOnRemove(key,region);
}
}

returnresult;
}

privatestaticboolAddItemToHandle(CacheItem<TCacheValue>item,BaseCacheHandle<TCacheValue>handle)
{
if(handle.Add(item))
{
handle.Stats.OnAdd(item);
returntrue;
}

returnfalse;
}

privatestaticvoidClearHandles(BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.Clear();
handle.Stats.OnClear();
}

////this.TriggerOnClear();
}

privatestaticvoidClearRegionHandles(stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

////this.TriggerOnClearRegion(region);
}

privatevoidEvictFromHandles(stringkey,stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
EvictFromHandle(key,region,handle);
}
}

privatevoidEvictFromHandle(stringkey,stringregion,BaseCacheHandle<TCacheValue>handle)
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug(
"Evicting '{0}:{1}' from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

boolresult;
if(string.IsNullOrWhiteSpace(region))
{
result=handle.Remove(key);
}
else
{
result=handle.Remove(key,region);
}

if(result)
{
handle.Stats.OnRemove(region);
}
}

privatevoidAddToHandles(CacheItem<TCacheValue>item,intfoundIndex)
{
if(_logTrace)
{
Logger.LogTrace(
"Start updating handles with [{0}].",
item);
}

if(foundIndex==0)
{
return;
}

// update all cache handles with lower order, up the list
for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<foundIndex)
{
if(_logTrace)
{
Logger.LogTrace("Updating handles, added [{0}] to handle '{1}'.",item,_cacheHandles[handleIndex].Configuration.Name);
}

_cacheHandles[handleIndex].Add(item);
}
}
}

privatevoidAddToHandlesBelow(CacheItem<TCacheValue>item,intfoundIndex)
{
if(item==null)
{
return;
}

if(_logTrace)
{
Logger.LogTrace("Add [{0}] to handles below handle '{1}'.",item,foundIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex>foundIndex)
{
if(_cacheHandles[handleIndex].Add(item))
{
_cacheHandles[handleIndex].Stats.OnAdd(item);
}
}
}
}

privatevoidEvictFromOtherHandles(stringkey,stringregion,intexcludeIndex)
{
if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

if(_logTrace)
{
Logger.LogTrace("Evict [{0}:{1}] from other handles excluding handle '{2}'.",region,key,excludeIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex!=excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidEvictFromHandlesAbove(stringkey,stringregion,intexcludeIndex)
{
if(_logTrace)
{
Logger.LogTrace("Evict from handles above: {0} {1}: above handle {2}.",key,region,excludeIndex);
}

if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidRegisterCacheBackplane(CacheBackplanebackplane)
{
NotNull(backplane,nameof(backplane));

// this should have been checked during activation already, just to be totally sure...
if(_cacheHandles.Any(p =>p.Configuration.IsBackplaneSource))
{
// added includeSource param to get the handles which need to be synced.
// in case the backplane source is non-distributed (in-memory), only remotely triggered remove and clear should also
// trigger a sync locally. For distributed caches, we expect that the distributed cache is already the source and in sync
// as that's the layer which triggered the event. In this case, only other in-memory handles above the distributed, would be synced.
varhandles=newFunc<bool,BaseCacheHandle<TCacheValue>[]>((includeSource)=>
{
varhandleList=newList<BaseCacheHandle<TCacheValue>>();
foreach(varhandlein_cacheHandles)
{
if(!handle.Configuration.IsBackplaneSource||
(includeSource&&handle.Configuration.IsBackplaneSource&&!handle.IsDistributedCache))
{
handleList.Add(handle);
}
}
returnhandleList.ToArray();
});

backplane.Changed+=(sender,args)=>
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Backplane event: [Changed] for '{1}:{0}'.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(false));
switch(args.Action)
{
caseCacheItemChangedEventAction.Add:
TriggerOnAdd(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Put:
TriggerOnPut(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Update:
TriggerOnUpdate(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;
}
};

backplane.Removed+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Remove] of {0} {1}.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(true));
TriggerOnRemove(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
};

backplane.Cleared+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear].");
}

ClearHandles(handles(true));
TriggerOnClear(CacheActionEventArgOrigin.Remote);
};

backplane.ClearedRegion+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear Region] region: {0}.",args.Region);
}

ClearRegionHandles(args.Region,handles(true));
TriggerOnClearRegion(args.Region,CacheActionEventArgOrigin.Remote);
};
}
}

privatevoidTriggerOnAdd(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnAdd?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnClear(CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClear?.Invoke(this,newCacheClearEventArgs(origin));
}

privatevoidTriggerOnClearRegion(stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClearRegion?.Invoke(this,newCacheClearRegionEventArgs(region,origin));
}

privatevoidTriggerOnGet(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnGet?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnPut(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnPut?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemove(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemove?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemoveByHandle(stringkey,stringregion,CacheItemRemovedReasonreason,intlevel,objectvalue)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemoveByHandle?.Invoke(this,newCacheItemRemovedEventArgs(key,region,reason,value,level));
}

privatevoidTriggerOnUpdate(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnUpdate?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}
}
}
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Globalization;
usingSystem.Linq;
usingCacheManager.Core.Internal;
usingMicrosoft.Extensions.Logging;
usingstaticCacheManager.Core.Utility.Guard;

namespaceCacheManager.Core
{
/// <summary>
/// The <see cref="BaseCacheManager{TCacheValue}"/> implements <see cref="ICacheManager{TCacheValue}"/> and is the main class
/// of this library.
/// The cache manager delegates all cache operations to the list of <see cref="BaseCacheHandle{T}"/>'s which have been
/// added. It will keep them in sync according to rules and depending on the configuration.
/// </summary>
/// <typeparam name="TCacheValue">The type of the cache value.</typeparam>
publicpartialclassBaseCacheManager<TCacheValue>:BaseCache<TCacheValue>,ICacheManager<TCacheValue>,IDisposable
{
privateclassNullLoggerFactory:ILoggerFactory
{
publicvoidAddProvider(ILoggerProviderprovider)
{
}

publicILoggerCreateLogger(stringcategoryName)
{
returnnewNullLogger();
}

publicvoidDispose()
{
}
}

privateclassNullLogger:ILogger<BaseCacheManager<TCacheValue>>
{
publicIDisposableBeginScope<TState>(TStatestate)=>null;

publicboolIsEnabled(LogLevellogLevel)=>false;

publicvoidLog<TState>(LogLevellogLevel,EventIdeventId,TStatestate,Exceptionexception,Func<TState,Exception,string>formatter)
{
// do nothing;
}
}

privatereadonlybool_logTrace=false;
privatereadonlyBaseCacheHandle<TCacheValue>[]_cacheHandles;
privatereadonlyCacheBackplane_cacheBackplane;

/// <summary>
/// Initializes a new instance of the <see cref="BaseCacheManager{TCacheValue}"/> class
/// using the specified <paramref name="configuration"/>.
/// If the name of the <paramref name="configuration"/> is defined, the cache manager will
/// use it. Otherwise a random string will be generated.
/// </summary>
/// <param name="configuration">
/// The configuration which defines the structure and complexity of the cache manager.
/// </param>
/// <param name="loggerFactory">Optional logger factory.</param>
/// <exception cref="System.ArgumentNullException">
/// When <paramref name="configuration"/> is null.
/// </exception>
/// <see cref="CacheFactory"/>
/// <see cref="CacheConfigurationBuilder"/>
/// <see cref="BaseCacheHandle{TCacheValue}"/>
publicBaseCacheManager(ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory=null)
:this(configuration?.Name??Guid.NewGuid().ToString(),configuration,loggerFactory??newNullLoggerFactory())
{
}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage","CA2200:RethrowToPreserveStackDetails",Justification="fine for now")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability","CA2000:Dispose objects before losing scope",Justification="nope")]
privateBaseCacheManager(stringname,ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory)
{
NotNullOrWhiteSpace(name,nameof(name));
NotNull(configuration,nameof(configuration));
NotNull(loggerFactory,nameof(loggerFactory));

Name=name;
Configuration=configuration;
varserializer=CacheReflectionHelper.CreateSerializer(configuration,loggerFactory);

Logger=loggerFactory.CreateLogger(this.GetType());

_logTrace=Logger.IsEnabled(LogLevel.Trace);

Logger.LogInformation("Cache manager: adding cache handles...");

try
{
_cacheHandles=CacheReflectionHelper.CreateCacheHandles(this,loggerFactory,serializer).ToArray();

varindex=0;
foreach(varhandlein_cacheHandles)
{
varhandleIndex=index;
handle.OnCacheSpecificRemove+=(sender,args)=>
{
// added sync for using backplane with in-memory caches on cache specific removal
// but commented for now, this is not really needed if all instances use the same expiration etc, would just cause duplicated events
////if (_cacheBackplane != null && handle.Configuration.IsBackplaneSource && !handle.IsDistributedCache)
////{
//// if (string.IsNullOrEmpty(args.Region))
//// {
//// _cacheBackplane.NotifyRemove(args.Key);
//// }
//// else
//// {
//// _cacheBackplane.NotifyRemove(args.Key, args.Region);
//// }
////}

// base cache handle does logging for this

if(Configuration.UpdateMode==CacheUpdateMode.Up)
{
if(_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.",handleIndex);
}

EvictFromHandlesAbove(args.Key,args.Region,handleIndex);
}

// moving down below cleanup, otherwise the item could still be in memory
TriggerOnRemoveByHandle(args.Key,args.Region,args.Reason,handleIndex+1,args.Value);
};

index++;
}

_cacheBackplane=CacheReflectionHelper.CreateBackplane(configuration,loggerFactory);
if(_cacheBackplane!=null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch(Exceptionex)
{
Logger.LogError(ex,"Error occurred while creating the cache manager.");
throwex.InnerException??ex;
}
}

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnAdd;

/// <inheritdoc />
publiceventEventHandler<CacheClearEventArgs>OnClear;

/// <inheritdoc />
publiceventEventHandler<CacheClearRegionEventArgs>OnClearRegion;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnGet;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnPut;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnRemove;

/// <inheritdoc />
publiceventEventHandler<CacheItemRemovedEventArgs>OnRemoveByHandle;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnUpdate;

/// <inheritdoc />
publicIReadOnlyCacheManagerConfigurationConfiguration{get;}

/// <inheritdoc />
publicIEnumerable<BaseCacheHandle<TCacheValue>>CacheHandles
=>newReadOnlyCollection<BaseCacheHandle<TCacheValue>>(
newList<BaseCacheHandle<TCacheValue>>(
_cacheHandles));

/// <summary>
/// Gets the configured cache backplane.
/// </summary>
/// <value>The backplane.</value>
publicCacheBackplaneBackplane=>_cacheBackplane;

/// <summary>
/// Gets the cache name.
/// </summary>
/// <value>The name of the cache.</value>
publicstringName{get;}

/// <inheritdoc />
protectedoverrideILoggerLogger{get;}

/// <inheritdoc />
publicoverridevoidClear()
{
CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear: flushing cache...");
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear: clearing handle {0}.",handle.Configuration.Name);
}

handle.Clear();
handle.Stats.OnClear();
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear: notifies backplane.");
}

_cacheBackplane.NotifyClear();
}

TriggerOnClear();
}

/// <inheritdoc />
publicoverridevoidClearRegion(stringregion)
{
NotNullOrWhiteSpace(region,nameof(region));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}.",region);
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0} in handle {1}.",region,handle.Configuration.Name);
}

handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}: notifies backplane [clear region].",region);
}

_cacheBackplane.NotifyClearRegion(region);
}

TriggerOnClearRegion(region);
}

/// <inheritdoc />
publicoverrideboolExists(stringkey)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}] exists on handle '{1}'.",key,handle.Configuration.Name);
}

if(handle.Exists(key))
{
returntrue;
}
}

returnfalse;
}

/// <inheritdoc />
publicoverrideboolExists(stringkey,stringregion)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}:{1}] exists on handle '{2}'.",region,key,handle.Configuration.Name);
}

if(handle.Exists(key,region))
{
returntrue;
}
}

returnfalse;
}

/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
publicoverridestringToString()=>
string.Format(CultureInfo.InvariantCulture,"Name: {0}, Handles: [{1}]",Name,string.Join(",",_cacheHandles.Select(p =>p.GetType().Name)));

/// <inheritdoc />
protectedinternaloverrideboolAddInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Add [{0}] started.",item);
}

varhandleIndex=_cacheHandles.Length-1;

varresult=AddItemToHandle(item,_cacheHandles[handleIndex]);

// evict from other handles in any case because if it exists, it might be a different version
// if not exist, its just a sanity check to invalidate other versions in upper layers.
EvictFromOtherHandles(item.Key,item.Region,handleIndex);

if(result)
{
// update backplane
if(_cacheBackplane!=null)
{
if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Add);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Add);
}

if(_logTrace)
{
Logger.LogTrace("Notified backplane 'change' because [{0}] was added.",item);
}
}

// trigger only once and not per handle and only if the item was added!
TriggerOnAdd(item.Key,item.Region);
}

returnresult;
}

/// <inheritdoc />
protectedinternaloverridevoidPutInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Put [{0}] started.",item);
}

foreach(varhandlein_cacheHandles)
{
if(handle.Configuration.EnableStatistics)
{
// check if it is really a new item otherwise the items count is crap because we
// count it every time, but use only the current handle to retrieve the item,
// otherwise we would trigger gets and find it in another handle maybe
varoldItem=string.IsNullOrWhiteSpace(item.Region)?
handle.GetCacheItem(item.Key):
handle.GetCacheItem(item.Key,item.Region);

handle.Stats.OnPut(item,oldItem==null);
}

if(_logTrace)
{
Logger.LogTrace(
"Put [{0}:{1}] successfully to handle '{2}'.",
item.Region,
item.Key,
handle.Configuration.Name);
}

handle.Put(item);
}

// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Put [{0}:{1}] was scuccessful. Notifying backplane [change].",item.Region,item.Key);
}

if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Put);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Put);
}
}

TriggerOnPut(item.Key,item.Region);
}

/// <inheritdoc />
protectedoverridevoidDispose(booldisposeManaged)
{
if(disposeManaged)
{
foreach(varhandlein_cacheHandles)
{
handle.Dispose();
}

if(_cacheBackplane!=null)
{
_cacheBackplane.Dispose();
}
}

base.Dispose(disposeManaged);
}

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey)=>
GetCacheItemInternal(key,null);

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey,stringregion)
{
CheckDisposed();

CacheItem<TCacheValue>cacheItem=null;

if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}] started.",region,key);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
varhandle=_cacheHandles[handleIndex];
if(string.IsNullOrWhiteSpace(region))
{
cacheItem=handle.GetCacheItem(key);
}
else
{
cacheItem=handle.GetCacheItem(key,region);
}

handle.Stats.OnGet(region);

if(cacheItem!=null)
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

// update last accessed, might be used for custom sliding implementations
cacheItem.LastAccessedUtc=DateTime.UtcNow;

// update other handles if needed
AddToHandles(cacheItem,handleIndex);
handle.Stats.OnHit(region);
TriggerOnGet(key,region);
break;
}
else
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], item NOT found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

handle.Stats.OnMiss(region);
}
}

returncacheItem;
}

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey)=>
RemoveInternal(key,null);

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey,stringregion)
{
CheckDisposed();

varresult=false;

if(_logTrace)
{
Logger.LogTrace("Removing [{0}:{1}].",region,key);
}

foreach(varhandlein_cacheHandles)
{
varhandleResult=false;
if(!string.IsNullOrWhiteSpace(region))
{
handleResult=handle.Remove(key,region);
}
else
{
handleResult=handle.Remove(key);
}

if(handleResult)
{
if(_logTrace)
{
Logger.LogTrace(
"Remove [{0}:{1}], successfully removed from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

result=true;
handle.Stats.OnRemove(region);
}
}

// See #311, send remove events anyways if the backlane is configured but no distributed cache is used.
varinProcOnly=_cacheHandles.Any(p =>!p.IsDistributedCache);

if(result||inProcOnly)
{
// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Removed [{0}:{1}], notifying backplane [remove].",region,key);
}

if(string.IsNullOrWhiteSpace(region))
{
_cacheBackplane.NotifyRemove(key);
}
else
{
_cacheBackplane.NotifyRemove(key,region);
}
}

if(result)
{
// trigger only once and not per handle
TriggerOnRemove(key,region);
}
}

returnresult;
}

privatestaticboolAddItemToHandle(CacheItem<TCacheValue>item,BaseCacheHandle<TCacheValue>handle)
{
if(handle.Add(item))
{
handle.Stats.OnAdd(item);
returntrue;
}

returnfalse;
}

privatestaticvoidClearHandles(BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.Clear();
handle.Stats.OnClear();
}

////this.TriggerOnClear();
}

privatestaticvoidClearRegionHandles(stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

////this.TriggerOnClearRegion(region);
}

privatevoidEvictFromHandles(stringkey,stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
EvictFromHandle(key,region,handle);
}
}

privatevoidEvictFromHandle(stringkey,stringregion,BaseCacheHandle<TCacheValue>handle)
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug(
"Evicting '{0}:{1}' from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

boolresult;
if(string.IsNullOrWhiteSpace(region))
{
result=handle.Remove(key);
}
else
{
result=handle.Remove(key,region);
}

if(result)
{
handle.Stats.OnRemove(region);
}
}

privatevoidAddToHandles(CacheItem<TCacheValue>item,intfoundIndex)
{
if(_logTrace)
{
Logger.LogTrace(
"Start updating handles with [{0}].",
item);
}

if(foundIndex==0)
{
return;
}

// update all cache handles with lower order, up the list
for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<foundIndex)
{
if(_logTrace)
{
Logger.LogTrace("Updating handles, added [{0}] to handle '{1}'.",item,_cacheHandles[handleIndex].Configuration.Name);
}

_cacheHandles[handleIndex].Add(item);
}
}
}

privatevoidAddToHandlesBelow(CacheItem<TCacheValue>item,intfoundIndex)
{
if(item==null)
{
return;
}

if(_logTrace)
{
Logger.LogTrace("Add [{0}] to handles below handle '{1}'.",item,foundIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex>foundIndex)
{
if(_cacheHandles[handleIndex].Add(item))
{
_cacheHandles[handleIndex].Stats.OnAdd(item);
}
}
}
}

privatevoidEvictFromOtherHandles(stringkey,stringregion,intexcludeIndex)
{
if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

if(_logTrace)
{
Logger.LogTrace("Evict [{0}:{1}] from other handles excluding handle '{2}'.",region,key,excludeIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex!=excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidEvictFromHandlesAbove(stringkey,stringregion,intexcludeIndex)
{
if(_logTrace)
{
Logger.LogTrace("Evict from handles above: {0} {1}: above handle {2}.",key,region,excludeIndex);
}

if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidRegisterCacheBackplane(CacheBackplanebackplane)
{
NotNull(backplane,nameof(backplane));

// this should have been checked during activation already, just to be totally sure...
if(_cacheHandles.Any(p =>p.Configuration.IsBackplaneSource))
{
// added includeSource param to get the handles which need to be synced.
// in case the backplane source is non-distributed (in-memory), only remotely triggered remove and clear should also
// trigger a sync locally. For distributed caches, we expect that the distributed cache is already the source and in sync
// as that's the layer which triggered the event. In this case, only other in-memory handles above the distributed, would be synced.
varhandles=newFunc<bool,BaseCacheHandle<TCacheValue>[]>((includeSource)=>
{
varhandleList=newList<BaseCacheHandle<TCacheValue>>();
foreach(varhandlein_cacheHandles)
{
if(!handle.Configuration.IsBackplaneSource||
(includeSource&&handle.Configuration.IsBackplaneSource&&!handle.IsDistributedCache))
{
handleList.Add(handle);
}
}
returnhandleList.ToArray();
});

backplane.Changed+=(sender,args)=>
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Backplane event: [Changed] for '{1}:{0}'.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(false));
switch(args.Action)
{
caseCacheItemChangedEventAction.Add:
TriggerOnAdd(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Put:
TriggerOnPut(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Update:
TriggerOnUpdate(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;
}
};

backplane.Removed+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Remove] of {0} {1}.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(true));
TriggerOnRemove(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
};

backplane.Cleared+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear].");
}

ClearHandles(handles(true));
TriggerOnClear(CacheActionEventArgOrigin.Remote);
};

backplane.ClearedRegion+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear Region] region: {0}.",args.Region);
}

ClearRegionHandles(args.Region,handles(true));
TriggerOnClearRegion(args.Region,CacheActionEventArgOrigin.Remote);
};
}
}

privatevoidTriggerOnAdd(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnAdd?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnClear(CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClear?.Invoke(this,newCacheClearEventArgs(origin));
}

privatevoidTriggerOnClearRegion(stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClearRegion?.Invoke(this,newCacheClearRegionEventArgs(region,origin));
}

privatevoidTriggerOnGet(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnGet?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnPut(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnPut?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemove(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemove?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemoveByHandle(stringkey,stringregion,CacheItemRemovedReasonreason,intlevel,objectvalue)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemoveByHandle?.Invoke(this,newCacheItemRemovedEventArgs(key,region,reason,value,level));
}

privatevoidTriggerOnUpdate(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnUpdate?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}
}
}
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Globalization;
usingSystem.Linq;
usingCacheManager.Core.Internal;
usingMicrosoft.Extensions.Logging;
usingstaticCacheManager.Core.Utility.Guard;

namespaceCacheManager.Core
{
/// <summary>
/// The <see cref="BaseCacheManager{TCacheValue}"/> implements <see cref="ICacheManager{TCacheValue}"/> and is the main class
/// of this library.
/// The cache manager delegates all cache operations to the list of <see cref="BaseCacheHandle{T}"/>'s which have been
/// added. It will keep them in sync according to rules and depending on the configuration.
/// </summary>
/// <typeparam name="TCacheValue">The type of the cache value.</typeparam>
publicpartialclassBaseCacheManager<TCacheValue>:BaseCache<TCacheValue>,ICacheManager<TCacheValue>,IDisposable
{
privateclassNullLoggerFactory:ILoggerFactory
{
publicvoidAddProvider(ILoggerProviderprovider)
{
}

publicILoggerCreateLogger(stringcategoryName)
{
returnnewNullLogger();
}

publicvoidDispose()
{
}
}

privateclassNullLogger:ILogger<BaseCacheManager<TCacheValue>>
{
publicIDisposableBeginScope<TState>(TStatestate)=>null;

publicboolIsEnabled(LogLevellogLevel)=>false;

publicvoidLog<TState>(LogLevellogLevel,EventIdeventId,TStatestate,Exceptionexception,Func<TState,Exception,string>formatter)
{
// do nothing;
}
}

privatereadonlybool_logTrace=false;
privatereadonlyBaseCacheHandle<TCacheValue>[]_cacheHandles;
privatereadonlyCacheBackplane_cacheBackplane;

/// <summary>
/// Initializes a new instance of the <see cref="BaseCacheManager{TCacheValue}"/> class
/// using the specified <paramref name="configuration"/>.
/// If the name of the <paramref name="configuration"/> is defined, the cache manager will
/// use it. Otherwise a random string will be generated.
/// </summary>
/// <param name="configuration">
/// The configuration which defines the structure and complexity of the cache manager.
/// </param>
/// <param name="loggerFactory">Optional logger factory.</param>
/// <exception cref="System.ArgumentNullException">
/// When <paramref name="configuration"/> is null.
/// </exception>
/// <see cref="CacheFactory"/>
/// <see cref="CacheConfigurationBuilder"/>
/// <see cref="BaseCacheHandle{TCacheValue}"/>
publicBaseCacheManager(ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory=null)
:this(configuration?.Name??Guid.NewGuid().ToString(),configuration,loggerFactory??newNullLoggerFactory())
{
}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage","CA2200:RethrowToPreserveStackDetails",Justification="fine for now")]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability","CA2000:Dispose objects before losing scope",Justification="nope")]
privateBaseCacheManager(stringname,ICacheManagerConfigurationconfiguration,ILoggerFactoryloggerFactory)
{
NotNullOrWhiteSpace(name,nameof(name));
NotNull(configuration,nameof(configuration));
NotNull(loggerFactory,nameof(loggerFactory));

Name=name;
Configuration=configuration;
varserializer=CacheReflectionHelper.CreateSerializer(configuration,loggerFactory);

Logger=loggerFactory.CreateLogger(this.GetType());

_logTrace=Logger.IsEnabled(LogLevel.Trace);

Logger.LogInformation("Cache manager: adding cache handles...");

try
{
_cacheHandles=CacheReflectionHelper.CreateCacheHandles(this,loggerFactory,serializer).ToArray();

varindex=0;
foreach(varhandlein_cacheHandles)
{
varhandleIndex=index;
handle.OnCacheSpecificRemove+=(sender,args)=>
{
// added sync for using backplane with in-memory caches on cache specific removal
// but commented for now, this is not really needed if all instances use the same expiration etc, would just cause duplicated events
////if (_cacheBackplane != null && handle.Configuration.IsBackplaneSource && !handle.IsDistributedCache)
////{
//// if (string.IsNullOrEmpty(args.Region))
//// {
//// _cacheBackplane.NotifyRemove(args.Key);
//// }
//// else
//// {
//// _cacheBackplane.NotifyRemove(args.Key, args.Region);
//// }
////}

// base cache handle does logging for this

if(Configuration.UpdateMode==CacheUpdateMode.Up)
{
if(_logTrace)
{
Logger.LogTrace("Cleaning handles above '{0}' because of remove event.",handleIndex);
}

EvictFromHandlesAbove(args.Key,args.Region,handleIndex);
}

// moving down below cleanup, otherwise the item could still be in memory
TriggerOnRemoveByHandle(args.Key,args.Region,args.Reason,handleIndex+1,args.Value);
};

index++;
}

_cacheBackplane=CacheReflectionHelper.CreateBackplane(configuration,loggerFactory);
if(_cacheBackplane!=null)
{
RegisterCacheBackplane(_cacheBackplane);
}
}
catch(Exceptionex)
{
Logger.LogError(ex,"Error occurred while creating the cache manager.");
throwex.InnerException??ex;
}
}

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnAdd;

/// <inheritdoc />
publiceventEventHandler<CacheClearEventArgs>OnClear;

/// <inheritdoc />
publiceventEventHandler<CacheClearRegionEventArgs>OnClearRegion;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnGet;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnPut;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnRemove;

/// <inheritdoc />
publiceventEventHandler<CacheItemRemovedEventArgs>OnRemoveByHandle;

/// <inheritdoc />
publiceventEventHandler<CacheActionEventArgs>OnUpdate;

/// <inheritdoc />
publicIReadOnlyCacheManagerConfigurationConfiguration{get;}

/// <inheritdoc />
publicIEnumerable<BaseCacheHandle<TCacheValue>>CacheHandles
=>newReadOnlyCollection<BaseCacheHandle<TCacheValue>>(
newList<BaseCacheHandle<TCacheValue>>(
_cacheHandles));

/// <summary>
/// Gets the configured cache backplane.
/// </summary>
/// <value>The backplane.</value>
publicCacheBackplaneBackplane=>_cacheBackplane;

/// <summary>
/// Gets the cache name.
/// </summary>
/// <value>The name of the cache.</value>
publicstringName{get;}

/// <inheritdoc />
protectedoverrideILoggerLogger{get;}

/// <inheritdoc />
publicoverridevoidClear()
{
CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear: flushing cache...");
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear: clearing handle {0}.",handle.Configuration.Name);
}

handle.Clear();
handle.Stats.OnClear();
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear: notifies backplane.");
}

_cacheBackplane.NotifyClear();
}

TriggerOnClear();
}

/// <inheritdoc />
publicoverridevoidClearRegion(stringregion)
{
NotNullOrWhiteSpace(region,nameof(region));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}.",region);
}

foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0} in handle {1}.",region,handle.Configuration.Name);
}

handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Clear region: {0}: notifies backplane [clear region].",region);
}

_cacheBackplane.NotifyClearRegion(region);
}

TriggerOnClearRegion(region);
}

/// <inheritdoc />
publicoverrideboolExists(stringkey)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}] exists on handle '{1}'.",key,handle.Configuration.Name);
}

if(handle.Exists(key))
{
returntrue;
}
}

returnfalse;
}

/// <inheritdoc />
publicoverrideboolExists(stringkey,stringregion)
{
foreach(varhandlein_cacheHandles)
{
if(_logTrace)
{
Logger.LogTrace("Checking if [{0}:{1}] exists on handle '{2}'.",region,key,handle.Configuration.Name);
}

if(handle.Exists(key,region))
{
returntrue;
}
}

returnfalse;
}

/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
publicoverridestringToString()=>
string.Format(CultureInfo.InvariantCulture,"Name: {0}, Handles: [{1}]",Name,string.Join(",",_cacheHandles.Select(p =>p.GetType().Name)));

/// <inheritdoc />
protectedinternaloverrideboolAddInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Add [{0}] started.",item);
}

varhandleIndex=_cacheHandles.Length-1;

varresult=AddItemToHandle(item,_cacheHandles[handleIndex]);

// evict from other handles in any case because if it exists, it might be a different version
// if not exist, its just a sanity check to invalidate other versions in upper layers.
EvictFromOtherHandles(item.Key,item.Region,handleIndex);

if(result)
{
// update backplane
if(_cacheBackplane!=null)
{
if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Add);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Add);
}

if(_logTrace)
{
Logger.LogTrace("Notified backplane 'change' because [{0}] was added.",item);
}
}

// trigger only once and not per handle and only if the item was added!
TriggerOnAdd(item.Key,item.Region);
}

returnresult;
}

/// <inheritdoc />
protectedinternaloverridevoidPutInternal(CacheItem<TCacheValue>item)
{
NotNull(item,nameof(item));

CheckDisposed();
if(_logTrace)
{
Logger.LogTrace("Put [{0}] started.",item);
}

foreach(varhandlein_cacheHandles)
{
if(handle.Configuration.EnableStatistics)
{
// check if it is really a new item otherwise the items count is crap because we
// count it every time, but use only the current handle to retrieve the item,
// otherwise we would trigger gets and find it in another handle maybe
varoldItem=string.IsNullOrWhiteSpace(item.Region)?
handle.GetCacheItem(item.Key):
handle.GetCacheItem(item.Key,item.Region);

handle.Stats.OnPut(item,oldItem==null);
}

if(_logTrace)
{
Logger.LogTrace(
"Put [{0}:{1}] successfully to handle '{2}'.",
item.Region,
item.Key,
handle.Configuration.Name);
}

handle.Put(item);
}

// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Put [{0}:{1}] was scuccessful. Notifying backplane [change].",item.Region,item.Key);
}

if(string.IsNullOrWhiteSpace(item.Region))
{
_cacheBackplane.NotifyChange(item.Key,CacheItemChangedEventAction.Put);
}
else
{
_cacheBackplane.NotifyChange(item.Key,item.Region,CacheItemChangedEventAction.Put);
}
}

TriggerOnPut(item.Key,item.Region);
}

/// <inheritdoc />
protectedoverridevoidDispose(booldisposeManaged)
{
if(disposeManaged)
{
foreach(varhandlein_cacheHandles)
{
handle.Dispose();
}

if(_cacheBackplane!=null)
{
_cacheBackplane.Dispose();
}
}

base.Dispose(disposeManaged);
}

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey)=>
GetCacheItemInternal(key,null);

/// <inheritdoc />
protectedoverrideCacheItem<TCacheValue>GetCacheItemInternal(stringkey,stringregion)
{
CheckDisposed();

CacheItem<TCacheValue>cacheItem=null;

if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}] started.",region,key);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
varhandle=_cacheHandles[handleIndex];
if(string.IsNullOrWhiteSpace(region))
{
cacheItem=handle.GetCacheItem(key);
}
else
{
cacheItem=handle.GetCacheItem(key,region);
}

handle.Stats.OnGet(region);

if(cacheItem!=null)
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

// update last accessed, might be used for custom sliding implementations
cacheItem.LastAccessedUtc=DateTime.UtcNow;

// update other handles if needed
AddToHandles(cacheItem,handleIndex);
handle.Stats.OnHit(region);
TriggerOnGet(key,region);
break;
}
else
{
if(_logTrace)
{
Logger.LogTrace("Get [{0}:{1}], item NOT found in handle[{2}] '{3}'.",region,key,handleIndex,handle.Configuration.Name);
}

handle.Stats.OnMiss(region);
}
}

returncacheItem;
}

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey)=>
RemoveInternal(key,null);

/// <inheritdoc />
protectedoverrideboolRemoveInternal(stringkey,stringregion)
{
CheckDisposed();

varresult=false;

if(_logTrace)
{
Logger.LogTrace("Removing [{0}:{1}].",region,key);
}

foreach(varhandlein_cacheHandles)
{
varhandleResult=false;
if(!string.IsNullOrWhiteSpace(region))
{
handleResult=handle.Remove(key,region);
}
else
{
handleResult=handle.Remove(key);
}

if(handleResult)
{
if(_logTrace)
{
Logger.LogTrace(
"Remove [{0}:{1}], successfully removed from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

result=true;
handle.Stats.OnRemove(region);
}
}

// See #311, send remove events anyways if the backlane is configured but no distributed cache is used.
varinProcOnly=_cacheHandles.Any(p =>!p.IsDistributedCache);

if(result||inProcOnly)
{
// update backplane
if(_cacheBackplane!=null)
{
if(_logTrace)
{
Logger.LogTrace("Removed [{0}:{1}], notifying backplane [remove].",region,key);
}

if(string.IsNullOrWhiteSpace(region))
{
_cacheBackplane.NotifyRemove(key);
}
else
{
_cacheBackplane.NotifyRemove(key,region);
}
}

if(result)
{
// trigger only once and not per handle
TriggerOnRemove(key,region);
}
}

returnresult;
}

privatestaticboolAddItemToHandle(CacheItem<TCacheValue>item,BaseCacheHandle<TCacheValue>handle)
{
if(handle.Add(item))
{
handle.Stats.OnAdd(item);
returntrue;
}

returnfalse;
}

privatestaticvoidClearHandles(BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.Clear();
handle.Stats.OnClear();
}

////this.TriggerOnClear();
}

privatestaticvoidClearRegionHandles(stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
handle.ClearRegion(region);
handle.Stats.OnClearRegion(region);
}

////this.TriggerOnClearRegion(region);
}

privatevoidEvictFromHandles(stringkey,stringregion,BaseCacheHandle<TCacheValue>[]handles)
{
foreach(varhandleinhandles)
{
EvictFromHandle(key,region,handle);
}
}

privatevoidEvictFromHandle(stringkey,stringregion,BaseCacheHandle<TCacheValue>handle)
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug(
"Evicting '{0}:{1}' from handle '{2}'.",
region,
key,
handle.Configuration.Name);
}

boolresult;
if(string.IsNullOrWhiteSpace(region))
{
result=handle.Remove(key);
}
else
{
result=handle.Remove(key,region);
}

if(result)
{
handle.Stats.OnRemove(region);
}
}

privatevoidAddToHandles(CacheItem<TCacheValue>item,intfoundIndex)
{
if(_logTrace)
{
Logger.LogTrace(
"Start updating handles with [{0}].",
item);
}

if(foundIndex==0)
{
return;
}

// update all cache handles with lower order, up the list
for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<foundIndex)
{
if(_logTrace)
{
Logger.LogTrace("Updating handles, added [{0}] to handle '{1}'.",item,_cacheHandles[handleIndex].Configuration.Name);
}

_cacheHandles[handleIndex].Add(item);
}
}
}

privatevoidAddToHandlesBelow(CacheItem<TCacheValue>item,intfoundIndex)
{
if(item==null)
{
return;
}

if(_logTrace)
{
Logger.LogTrace("Add [{0}] to handles below handle '{1}'.",item,foundIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex>foundIndex)
{
if(_cacheHandles[handleIndex].Add(item))
{
_cacheHandles[handleIndex].Stats.OnAdd(item);
}
}
}
}

privatevoidEvictFromOtherHandles(stringkey,stringregion,intexcludeIndex)
{
if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

if(_logTrace)
{
Logger.LogTrace("Evict [{0}:{1}] from other handles excluding handle '{2}'.",region,key,excludeIndex);
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex!=excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidEvictFromHandlesAbove(stringkey,stringregion,intexcludeIndex)
{
if(_logTrace)
{
Logger.LogTrace("Evict from handles above: {0} {1}: above handle {2}.",key,region,excludeIndex);
}

if(excludeIndex<0||excludeIndex>=_cacheHandles.Length)
{
thrownewArgumentOutOfRangeException(nameof(excludeIndex));
}

for(varhandleIndex=0;handleIndex<_cacheHandles.Length;handleIndex++)
{
if(handleIndex<excludeIndex)
{
EvictFromHandle(key,region,_cacheHandles[handleIndex]);
}
}
}

privatevoidRegisterCacheBackplane(CacheBackplanebackplane)
{
NotNull(backplane,nameof(backplane));

// this should have been checked during activation already, just to be totally sure...
if(_cacheHandles.Any(p =>p.Configuration.IsBackplaneSource))
{
// added includeSource param to get the handles which need to be synced.
// in case the backplane source is non-distributed (in-memory), only remotely triggered remove and clear should also
// trigger a sync locally. For distributed caches, we expect that the distributed cache is already the source and in sync
// as that's the layer which triggered the event. In this case, only other in-memory handles above the distributed, would be synced.
varhandles=newFunc<bool,BaseCacheHandle<TCacheValue>[]>((includeSource)=>
{
varhandleList=newList<BaseCacheHandle<TCacheValue>>();
foreach(varhandlein_cacheHandles)
{
if(!handle.Configuration.IsBackplaneSource||
(includeSource&&handle.Configuration.IsBackplaneSource&&!handle.IsDistributedCache))
{
handleList.Add(handle);
}
}
returnhandleList.ToArray();
});

backplane.Changed+=(sender,args)=>
{
if(Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug("Backplane event: [Changed] for '{1}:{0}'.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(false));
switch(args.Action)
{
caseCacheItemChangedEventAction.Add:
TriggerOnAdd(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Put:
TriggerOnPut(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;

caseCacheItemChangedEventAction.Update:
TriggerOnUpdate(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
break;
}
};

backplane.Removed+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Remove] of {0} {1}.",args.Key,args.Region);
}

EvictFromHandles(args.Key,args.Region,handles(true));
TriggerOnRemove(args.Key,args.Region,CacheActionEventArgOrigin.Remote);
};

backplane.Cleared+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear].");
}

ClearHandles(handles(true));
TriggerOnClear(CacheActionEventArgOrigin.Remote);
};

backplane.ClearedRegion+=(sender,args)=>
{
if(_logTrace)
{
Logger.LogTrace("Backplane event: [Clear Region] region: {0}.",args.Region);
}

ClearRegionHandles(args.Region,handles(true));
TriggerOnClearRegion(args.Region,CacheActionEventArgOrigin.Remote);
};
}
}

privatevoidTriggerOnAdd(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnAdd?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnClear(CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClear?.Invoke(this,newCacheClearEventArgs(origin));
}

privatevoidTriggerOnClearRegion(stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnClearRegion?.Invoke(this,newCacheClearRegionEventArgs(region,origin));
}

privatevoidTriggerOnGet(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnGet?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnPut(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnPut?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemove(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemove?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}

privatevoidTriggerOnRemoveByHandle(stringkey,stringregion,CacheItemRemovedReasonreason,intlevel,objectvalue)
{
NotNullOrWhiteSpace(key,nameof(key));
OnRemoveByHandle?.Invoke(this,newCacheItemRemovedEventArgs(key,region,reason,value,level));
}

privatevoidTriggerOnUpdate(stringkey,stringregion,CacheActionEventArgOriginorigin=CacheActionEventArgOrigin.Local)
{
OnUpdate?.Invoke(this,newCacheActionEventArgs(key,region,origin));
}
}
}