/// <summary>
/// Instances of caching provider.
/// </summary>
/// <returns>The Implemments provider of cache system defind in config.</returns>
public static CachingProvider Instance(ProviderLevel Level)
{
if (providerInstances.ContainsKey(Level))
{
return(providerInstances[Level]);
}
return(defaultCachingProvider);
}
/// <summary>
/// Instances of provider.
/// </summary>
/// <returns>The Implemments provider of system defind in config.</returns>
public static EventQueueProvider Instance(ProviderLevel Level)
{
if (providerInstances.ContainsKey(Level))
{
return(providerInstances[Level]);
}
return(defaultEventQueueProvider);
}
///-----------------------------------------------------------------------------
/// <summary>
/// Constructs a new CacheItemArgs Object
/// </summary>
/// <param name="key"></param>
/// <param name="timeout"></param>
/// <param name="level"></param>
/// <param name="parameters"></param>
///-----------------------------------------------------------------------------
public CacheItemArgs(string key, int timeout, int expireTimeout, ProviderLevel level, params object[] parameters)
{
CacheKey = key;
CacheTimeOutMinutes = timeout;
ExpireTimeOutMinutes = expireTimeout;
Level = level;
Params = parameters;
}
public static DataStoreProvider Instance(ProviderLevel Level)
{
if (providerInstances.ContainsKey(Level))
{
return(providerInstances[Level]);
}
return(defaultProvider);
}
public void Publish(IntegrationEvent @event, ProviderLevel level)
{
var eventName = _subsManager.GetEventKey(@event);
_logger.LogInformation($"Publish Start:{eventName}, ID:{@event.Id}");
Providers.EventQueueProvider.Instance(level).Publish(@event);
_logger.LogInformation($"Publish End:{eventName}, ID:{@event.Id}");
}
public long DecrementValueInHash(string hashId, string key, int count, ProviderLevel level)
{
var provider = CachingProvider.Instance(level);
if (!provider.IsDistributedCache())
{
object @lock = UniqueObject.GetUniqueObject <object>(key);
lock (@lock)
{
var retVal = provider.DecrementValueInHash(hashId, key, count);
UniqueObject.RemoveUniqueObject(key);
return(retVal);
}
}
return(provider.DecrementValueInHash(hashId, key, count));
}
public bool RemoveEntryFromHash <TKey>(string hashId, TKey key, ProviderLevel level)
{
return(CachingProvider.Instance(level).RemoveEntryFromHash <TKey>(hashId, key));
}
public void SetEntryInHash <TKey, T>(string hashId, TKey key, T value, ProviderLevel level)
{
CachingProvider.Instance(level).SetEntryInHash <TKey, T>(hashId, key, value);
}
public T GetValueFromHash <TKey, T>(string hashId, TKey key, ProviderLevel level)
{
return(CachingProvider.Instance(level).GetValueFromHash <TKey, T>(hashId, key));
}
public void RemoveList(string listName, ProviderLevel level)
{
CachingProvider.Instance(level).RemoveList(listName);
}
public long GetHashCount(string hashId, ProviderLevel level)
{
var count = CachingProvider.Instance(level).GetHashCount(hashId);
return(count);
}
///-----------------------------------------------------------------------------
/// <summary>
/// Constructs a new CacheItemArgs Object
/// </summary>
/// <param name="key"></param>
/// <param name="level"></param>
///-----------------------------------------------------------------------------
public CacheItemArgs(string key, ProviderLevel level)
: this(key, 20, 0, level, null)
{
}
public void RemoveFromList <T>(string listName, T value, ProviderLevel level)
{
CachingProvider.Instance(level).RemoveFromList <T>(listName, value);
}
public TObject GetCache <TObject>(string CacheKey, string scope = null, ProviderLevel level = ProviderLevel.Normal)
{
TObject objObject = CachingProvider.Instance(level).GetItem <TObject>(CacheKey, scope);
return(objObject);
}
public void SetCache(string CacheKey, object objObject, string Scope = null, DateTimeOffset?AbsoluteExpiration = null, TimeSpan?SlidingExpiration = null, ProviderLevel level = ProviderLevel.Normal,
FileCacheDependency objDependency = null, RemoveDelegate OnRemoveCallback = null)
{
if (objObject != null)
{
//if no OnRemoveCallback value is specified, use the default method
if (OnRemoveCallback == null)
{
OnRemoveCallback = ItemRemovedCallback;
}
CachingProvider.Instance(level).Insert(CacheKey, objObject, Scope, AbsoluteExpiration, SlidingExpiration, objDependency, OnRemoveCallback);
}
}
public List <T> GetListRange <T>(string listName, ProviderLevel level, long start = 0, long stop = -1)
{
var items = CachingProvider.Instance(level).GetListRange <T>(listName, start, stop);
return(items);
}
public List <T> Sort <T>(string collectionKey, string byField, bool fieldIsNumber, int skip, int take, bool isAscending, ProviderLevel level)
{
return(CachingProvider.Instance(level).Sort <T>(collectionKey, byField, fieldIsNumber, skip, take, isAscending));
}
public long GetListCount(string listName, ProviderLevel level)
{
var count = CachingProvider.Instance(level).GetListCount(listName);
return(count);
}
public async Task <bool> Update <T>(Expression <Func <T, bool> > filter, T doc, ProviderLevel level)
{
return(await DataStoreProvider.Instance(level).Update(filter, doc));
}
public async Task <T> IncrementField <T>(Expression <Func <T, bool> > filter, string field, int amount, ProviderLevel level)
{
return(await DataStoreProvider.Instance(level).IncrementField(filter, field, amount));
}
public long DecrementValue(string key, Func <long> initialCallBack, int count = 1, int expiredMinutes = 0, ProviderLevel level = ProviderLevel.Normal)
{
var provider = CachingProvider.Instance(level);
if (!provider.IsDistributedCache())
{
object @lock = UniqueObject.GetUniqueObject <object>(key);
lock (@lock)
{
var retVal = provider.DecrementValue(key, count, expiredMinutes, initialCallBack);
UniqueObject.RemoveUniqueObject(key);
return(retVal);
}
}
return(provider.DecrementValue(key, count, expiredMinutes, initialCallBack));
}
public async Task <bool> RemoveMany <T>(Expression <Func <T, bool> > filter, ProviderLevel level)
{
return(await DataStoreProvider.Instance(level).RemoveMany(filter));
}
public T GetItemFromList <T>(string listName, int listIndex, ProviderLevel level)
{
var objValue = CachingProvider.Instance(level).GetItemFromList <T>(listName, listIndex);
return(objValue);
}
public CacheItemArgs(string key, int timeoutMinutes, int expireTimeoutMinutes, ProviderLevel level)
: this(key, timeoutMinutes, expireTimeoutMinutes, level, null)
{
}
public bool ExpireItem(string cacheKey, DateTime?expireTime, ProviderLevel level)
{
return(CachingProvider.Instance(level).ExpireItem(cacheKey, expireTime));
}
public void SetItemInList <T>(string listName, int listIndex, T value, ProviderLevel level)
{
CachingProvider.Instance(level).SetItemInList <T>(listName, listIndex, value);
}
public void RemoveCache(string CacheKey, ProviderLevel level, string Scope = null)
{
CachingProvider.Instance(level).Remove(CacheKey, Scope);
}
public void EnqueueList <T>(string listName, T value, ProviderLevel level)
{
CachingProvider.Instance(level).EnqueueList <T>(listName, value);
}
public T DequeueList <T>(string listName, ProviderLevel level)
{
var objValue = CachingProvider.Instance(level).DequeueList <T>(listName);
return(objValue);
}
public async Task InsertMany <T>(IEnumerable <T> documents, ProviderLevel level)
{
await DataStoreProvider.Instance(level).InsertMany(documents);
}
