/// <summary>
/// Set the specified cacheKey, cacheValue and expiration.
/// </summary>
/// <returns>The set.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override void BaseSet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
//var valExpiration = expiration.Seconds <= 1 ? expiration : TimeSpan.FromSeconds(expiration.Seconds / 2);
//var val = new CacheValue<T>(cacheValue, true, valExpiration);
_cache.Set(cacheKey, cacheValue, expiration);
}
/// <summary>
/// Set the specified cacheKey, cacheValue and expiration.
/// </summary>
/// <returns>The set.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public void Set <T>(string cacheKey, T cacheValue, TimeSpan expiration) where T : class
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
_cache.Set(cacheKey, cacheValue, expiration);
_cacheKeys.Add(cacheKey);
}
/// <summary>
/// Sets all async.
/// </summary>
/// <returns>The all async.</returns>
/// <param name="values">Values.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task SetAllAsync <T>(IDictionary <string, T> values, TimeSpan expiration)
{
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
ArgumentCheck.NotNullAndCountGTZero(values, nameof(values));
var newDict = new Dictionary <string, T>();
foreach (var item in values)
{
//var valExpiration = expiration.Seconds <= 1 ? expiration : TimeSpan.FromSeconds(expiration.Seconds / 2);
//var val = new CacheValue<T>(item.Value, true, valExpiration);
newDict.Add(BuildCacheKey(this._name, item.Key), item.Value);
}
await Task.Run(() => _cache.SetAll(newDict, expiration));
}
public async Task SetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (_options.MaxRdSecond > 0)
{
var addSec = new Random().Next(1, _options.MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
var dateTimeOffset = DateTimeOffset.Now.Add(expiration);
await Task.Run(() => { _caching.Set(new CacheEntry(cacheKey, cacheValue, dateTimeOffset)); });
}
/// <summary>
/// Sets all async.
/// </summary>
/// <returns>The all async.</returns>
/// <param name="values">Values.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task SetAllAsync <T>(IDictionary <string, T> values, TimeSpan expiration) where T : class
{
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
ArgumentCheck.NotNullAndCountGTZero(values, nameof(values));
await _localCachingProvider.SetAllAsync(values, expiration);
try
{
await _distributedCachingProvider.SetAllAsync(values, expiration);
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Tries the set.
/// </summary>
/// <returns><c>true</c>, if set was tryed, <c>false</c> otherwise.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public bool TrySet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (_cache.TryGetValue(BuildCacheKey(Name, cacheKey), out var obj))
{
return(false);
}
else
{
Set(cacheKey, cacheValue, expiration);
return(true);
}
}
public override CacheValue<T> BaseGet<T>(string cacheKey, Func<T> dataRetriever, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
var path = GetRawPath(cacheKey);
if (File.Exists(path))
{
var cached = GetDiskCacheValue(path);
if (cached.Expiration > DateTimeOffset.UtcNow)
{
var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance));
OnCacheMiss(cacheKey);
return new CacheValue<T>(t, true);
}
}
OnCacheMiss(cacheKey);
// TODO: how to add mutex key here
if (!_cacheKeysMap.TryAdd($"{cacheKey}_Lock", "1"))
{
System.Threading.Thread.Sleep(_options.SleepMs);
return Get(cacheKey, dataRetriever, expiration);
}
var res = dataRetriever();
if (res != null || _options.CacheNulls)
{
Set(cacheKey, res, expiration);
// remove mutex key
_cacheKeysMap.TryRemove($"{cacheKey}_Lock", out _);
return new CacheValue<T>(res, true);
}
else
{
// remove mutex key
_cacheKeysMap.TryRemove($"{cacheKey}_Lock", out _);
return CacheValue<T>.NoValue;
}
}
/// <summary>
/// Get the specified cacheKey, dataRetriever and expiration.
/// </summary>
/// <returns>The get.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="dataRetriever">Data retriever.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public CacheValue <T> Get <T>(string cacheKey, Func <T> dataRetriever, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
var result = _cache.Get <byte[]>(cacheKey);
if (result != null)
{
CacheStats.OnHit();
if (_options.EnableLogging)
{
_logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}");
}
var value = _serializer.Deserialize <T>(result);
return(new CacheValue <T>(value, true));
}
CacheStats.OnMiss();
if (_options.EnableLogging)
{
_logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}");
}
if (!_cache.Set($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs).Seconds, RedisExistence.Nx))
{
System.Threading.Thread.Sleep(_options.SleepMs);
return(Get(cacheKey, dataRetriever, expiration));
}
var item = dataRetriever();
if (item != null)
{
Set(cacheKey, item, expiration);
//remove mutex key
_cache.Del($"{cacheKey}_Lock");
return(new CacheValue <T>(item, true));
}
else
{
return(CacheValue <T> .NoValue);
}
}
/// <summary>
/// Gets the specified cacheKey, dataRetriever and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="dataRetriever">Data retriever.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override async Task <CacheValue <T> > BaseGetAsync <T>(string cacheKey, Func <Task <T> > dataRetriever, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
var redisValue = await _cache.StringGetAsync(cacheKey);
var result = Deserialize <T>(cacheKey, redisValue);
TrackCacheStats(cacheKey, result);
if (result.HasValue)
{
return(result);
}
var flag = await _cache.StringSetAsync($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs), When.NotExists);
if (!flag)
{
await Task.Delay(_options.SleepMs);
return(await GetAsync(cacheKey, dataRetriever, expiration));
}
var item = await dataRetriever();
if (item != null || _options.CacheNulls)
{
await SetAsync(cacheKey, item, expiration);
//remove mutex key
await _cache.KeyDeleteAsync($"{cacheKey}_Lock");
result = new CacheValue <T>(item, true);
}
else
{
//remove mutex key
await _cache.KeyDeleteAsync($"{cacheKey}_Lock");
result = CacheValue <T> .NoValue;
}
return(result);
}
/// <summary>
/// Set the specified cacheKey, cacheValue and expiration.
/// </summary>
/// <returns>The set.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
protected override void BaseSet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (_cacheOptions.MaxRdSecond > 0)
{
var addSec = new Random().Next(1, _cacheOptions.MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
_redisDb.StringSet(
cacheKey,
_serializer.Serialize(cacheValue),
expiration);
}
/// <summary>
/// Sets the specified cacheKey, cacheValue and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task SetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration) where T : class
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
await _cache.StringSetAsync(
cacheKey,
_serializer.Serialize(cacheValue),
expiration);
}
/// <summary>
/// Get the specified cacheKey, dataRetriever and expiration.
/// </summary>
/// <returns>The get.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="dataRetriever">Data retriever.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override CacheValue <T> BaseGet <T>(string cacheKey, Func <T> dataRetriever, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (_memcachedClient.Get(this.HandleCacheKey(cacheKey)) is T result)
{
CacheStats.OnHit();
if (_options.EnableLogging)
{
_logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}");
}
return(new CacheValue <T>(result, true));
}
CacheStats.OnMiss();
if (_options.EnableLogging)
{
_logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}");
}
var flag = _memcachedClient.Store(Enyim.Caching.Memcached.StoreMode.Add, this.HandleCacheKey($"{cacheKey}_Lock"), 1, TimeSpan.FromMilliseconds(_options.LockMs));
if (!flag)
{
System.Threading.Thread.Sleep(_options.SleepMs);
return(Get(cacheKey, dataRetriever, expiration));
}
var item = dataRetriever();
if (item != null)
{
this.Set(cacheKey, item, expiration);
_memcachedClient.Remove(this.HandleCacheKey($"{cacheKey}_Lock"));
return(new CacheValue <T>(item, true));
}
else
{
_memcachedClient.Remove(this.HandleCacheKey($"{cacheKey}_Lock"));
return(CacheValue <T> .NoValue);
}
}
/// <summary>
/// Sets the specified cacheKey, cacheValue and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override async Task BaseSetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
await _cache.StringSetAsync(
cacheKey,
_serializer.Serialize(cacheValue),
expiration);
}
/// <summary>
/// Gets the specified cacheKey, dataRetriever and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="dataRetriever">Data retriever.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override async Task <CacheValue <T> > BaseGetAsync <T>(string cacheKey, Func <Task <T> > dataRetriever, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
var list = await _cache.QueryAsync <string>(ConstSQL.GETSQL, new
{
cachekey = cacheKey,
name = _name
});
var dbResult = list.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(dbResult))
{
if (_options.EnableLogging)
{
_logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}");
}
CacheStats.OnHit();
return(new CacheValue <T>(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(dbResult), true));
}
CacheStats.OnMiss();
if (_options.EnableLogging)
{
_logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}");
}
var item = await dataRetriever?.Invoke();
if (item != null)
{
await SetAsync(cacheKey, item, expiration);
return(new CacheValue <T>(item, true));
}
else
{
return(CacheValue <T> .NoValue);
}
}
/// <summary>
/// Sets the specified cacheKey, cacheValue and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task SetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)// where T : class
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
await Task.Run(() =>
{
_cache.Set(BuildCacheKey(Name, cacheKey), cacheValue, expiration);
_cacheKeys.Add(BuildCacheKey(Name, cacheKey));
});
}
/// <summary>
/// Tries the set async.
/// </summary>
/// <returns>The set async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override Task <bool> BaseTrySetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
return(_memcachedClient.StoreAsync(
Enyim.Caching.Memcached.StoreMode.Add,
this.HandleCacheKey(cacheKey),
ConvertToStoredValue(cacheValue),
expiration));
}
public override void BaseSet<T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
var (path, fileName) = GetFilePath(cacheKey);
var bytes = BuildDiskCacheValue(cacheValue, expiration);
using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
{
stream.Write(bytes, 0, bytes.Length);
//return true;
}
AppendKey(cacheKey, fileName);
}
/// <summary>
/// Gets the specified cacheKey, dataRetriever and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="dataRetriever">Data retriever.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task <CacheValue <T> > GetAsync <T>(string cacheKey, Func <Task <T> > dataRetriever, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
var result = await _localCache.GetAsync <T>(cacheKey);
if (result.HasValue)
{
return(result);
}
result = await _distributedCache.GetAsync <T>(cacheKey, dataRetriever, expiration);
return(result.HasValue
? result
: CacheValue <T> .NoValue);
}
/// <summary>
/// Set the specified cacheKey, cacheValue and expiration.
/// </summary>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override void BaseSet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
_cache.Set(
cacheKey,
_serializer.Serialize(cacheValue),
(int)expiration.TotalSeconds
);
}
/// <summary>
/// Set the specified cacheKey, cacheValue and expiration.
/// </summary>
/// <returns>The set.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override void BaseSet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
_cache.Upsert(new CacheItem
{
cachekey = cacheKey,
name = _name,
cachevalue = Newtonsoft.Json.JsonConvert.SerializeObject(cacheValue),
expiration = DateTimeOffset.UtcNow.Add(expiration).ToUnixTimeSeconds()
});
}
/// <summary>
/// Tries the set async.
/// </summary>
/// <returns>The set async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public Task <bool> TrySetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
return(_cache.StringSetAsync(
cacheKey,
_serializer.Serialize(cacheValue),
expiration,
When.NotExists
));
}
/// <summary>
/// Tries the set async.
/// </summary>
/// <returns>The set async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task <bool> TrySetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
return(await _cache.SetAsync(
cacheKey,
_serializer.Serialize(cacheValue),
expiration.Seconds,
RedisExistence.Nx
));
}
/// <summary>
/// Tries the set async.
/// </summary>
/// <returns>The set async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
protected override Task <bool> BaseTrySetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (_cacheOptions.MaxRdSecond > 0)
{
var addSec = new Random().Next(1, _cacheOptions.MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
return(_redisDb.StringSetAsync(
cacheKey,
_serializer.Serialize(cacheValue),
expiration,
When.NotExists
));
}
/// <summary>
/// Sets all.
/// </summary>
/// <param name="values">Values.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public void SetAll <T>(IDictionary <string, T> values, TimeSpan expiration) where T : class
{
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
ArgumentCheck.NotNullAndCountGTZero(values, nameof(values));
var tran = _cache.BeginTransaction();
foreach (var item in values)
{
_cache.Execute(ConstSQL.SETSQL, new
{
cachekey = item.Key,
cachevalue = Newtonsoft.Json.JsonConvert.SerializeObject(item.Value),
expiration = expiration.Ticks / 10000000
}, tran);
}
tran.Commit();
}
/// <summary>
/// Tries the set.
/// </summary>
/// <returns><c>true</c>, if set was tryed, <c>false</c> otherwise.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override bool BaseTrySet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
return(_cache.StringSet(
cacheKey,
_serializer.Serialize(cacheValue),
expiration,
When.NotExists
));
}
/// <summary>
/// Sets the specified cacheKey, cacheValue and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task SetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)// where T : class
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
await _cache.ExecuteAsync(ConstSQL.SETSQL, new
{
cachekey = cacheKey,
cachevalue = Newtonsoft.Json.JsonConvert.SerializeObject(cacheValue),
expiration = expiration.Ticks / 10000000
});
}
/// <summary>
/// Gets the specified cacheKey, dataRetriever and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="dataRetriever">Data retriever.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override async Task <CacheValue <T> > BaseGetAsync <T>(string cacheKey, Func <Task <T> > dataRetriever,
TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
var result = _cache.Get <T>(cacheKey);
if (result.HasValue)
{
OnCacheHit(cacheKey);
return(result);
}
OnCacheMiss(cacheKey);
if (!_cache.Add($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs)))
{
//wait for some ms
await Task.Delay(_options.SleepMs);
return(await GetAsync(cacheKey, dataRetriever, expiration));
}
var res = await dataRetriever();
if (res != null || _options.CacheNulls)
{
await SetAsync(cacheKey, res, expiration);
//remove mutex key
_cache.Remove($"{cacheKey}_Lock");
return(new CacheValue <T>(res, true));
}
else
{
//remove mutex key
_cache.Remove($"{cacheKey}_Lock");
return(CacheValue <T> .NoValue);
}
}
/// <summary>
/// Sets the specified cacheKey, cacheValue and expiration async.
/// </summary>
/// <returns>The async.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public async Task SetAsync <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration = expiration.Add(TimeSpan.FromSeconds(addSec));
}
await Task.Run(() =>
{
//var valExpiration = expiration.Seconds <= 1 ? expiration : TimeSpan.FromSeconds(expiration.Seconds / 2);
//var val = new CacheValue<T>(cacheValue, true, valExpiration);
_cache.Set(BuildCacheKey(Name, cacheKey), cacheValue, expiration);
});
}
/// <summary>
/// Get the specified cacheKey, dataRetriever and expiration.
/// </summary>
/// <returns>The get.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="dataRetriever">Data retriever.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override CacheValue <T> BaseGet <T>(string cacheKey, Func <T> dataRetriever, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
////mutex key
//Lock(cacheKey);
var result = _cache.Get <T>(cacheKey);
if (result.HasValue)
{
OnCacheMiss(cacheKey);
return(result);
}
OnCacheMiss(cacheKey);
if (!_cache.Add($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs)))
{
System.Threading.Thread.Sleep(_options.SleepMs);
return(Get(cacheKey, dataRetriever, expiration));
}
var res = dataRetriever();
if (res != null || _options.CacheNulls)
{
Set(cacheKey, res, expiration);
//remove mutex key
_cache.Remove($"{cacheKey}_Lock");
return(new CacheValue <T>(res, true));
}
else
{
//remove mutex key
_cache.Remove($"{cacheKey}_Lock");
return(CacheValue <T> .NoValue);
}
}
/// <summary>
/// Set the specified cacheKey, cacheValue and expiration.
/// </summary>
/// <returns>The set.</returns>
/// <param name="cacheKey">Cache key.</param>
/// <param name="cacheValue">Cache value.</param>
/// <param name="expiration">Expiration.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public override void BaseSet <T>(string cacheKey, T cacheValue, TimeSpan expiration)
{
ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
if (MaxRdSecond > 0)
{
var addSec = new Random().Next(1, MaxRdSecond);
expiration.Add(new TimeSpan(0, 0, addSec));
}
_cache.Execute(ConstSQL.SETSQL, new
{
cachekey = cacheKey,
name = _name,
cachevalue = Newtonsoft.Json.JsonConvert.SerializeObject(cacheValue),
expiration = expiration.Ticks / 10000000
});
}
