/// <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 }); }