/// <summary> /// Sets the async. /// </summary> /// <returns>The async.</returns> /// <param name="key">Key.</param> /// <param name="entry">Entry.</param> /// <param name="validFor">Valid for.</param> public async Task SetAsync(string key, IResponseCacheEntry entry, TimeSpan validFor) { if (entry is CachedResponse cachedResponse) { var segmentStream = new SegmentWriteStream(StreamUtilities.BodySegmentSize); cachedResponse.Body.CopyTo(segmentStream); await _provider.SetAsync( key, new EasyCachingResponse { Created = cachedResponse.Created, StatusCode = cachedResponse.StatusCode, Headers = cachedResponse.Headers, BodySegments = segmentStream.GetSegments(), BodyLength = segmentStream.Length }, validFor); } else { await _provider.SetAsync( key, entry, validFor); } }
/// <summary> /// Sets the async. /// </summary> /// <returns>The async.</returns> /// <param name="key">Key.</param> /// <param name="entry">Entry.</param> /// <param name="validFor">Valid for.</param> public async Task SetAsync(string key, IResponseCacheEntry entry, TimeSpan validFor) { var cachedResponse = entry as CachedResponse; if (cachedResponse != null) { await _provider.SetAsync( key, new EasyCachingResponse { Created = cachedResponse.Created, StatusCode = cachedResponse.StatusCode, Headers = cachedResponse.Headers.ToDictionary(x => x.Key, x => x.Value.ToArray()), Body = this.GetBytes(cachedResponse.Body) }, validFor); } else { await _provider.SetAsync( key, entry, validFor); } }
/// <summary> /// Gets the specified cacheKey async. /// </summary> /// <returns>The async.</returns> /// <param name="cacheKey">Cache key.</param> /// <typeparam name="T">The 1st type parameter.</typeparam> public async Task <CacheValue <T> > GetAsync <T>(string cacheKey) { ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); var cacheValue = await _localCache.GetAsync <T>(cacheKey); if (cacheValue.HasValue) { return(cacheValue); } if (_options.EnableLogging) { _logger.LogTrace($"local cache can not get the value of {cacheKey}"); } cacheValue = await _distributedCache.GetAsync <T>(cacheKey); if (cacheValue.HasValue) { //TODO: What about the value of expiration? Form configuration or others? await _localCache.SetAsync(cacheKey, cacheValue.Value, TimeSpan.FromSeconds(60)); return(cacheValue); } if (_options.EnableLogging) { _logger.LogTrace($"distributed cache can not get the value of {cacheKey}"); } return(CacheValue <T> .NoValue); }
/// <summary> /// Gets the specified cacheKey async. /// </summary> /// <returns>The async.</returns> /// <param name="cacheKey">Cache key.</param> /// <typeparam name="T">The 1st type parameter.</typeparam> public async Task <CacheValue <T> > GetAsync <T>(string cacheKey) { ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); var cacheValue = await _localCache.GetAsync <T>(cacheKey); if (cacheValue.HasValue) { return(cacheValue); } _logger?.LogDebug("local cache can not get the value of {0}", cacheKey); try { cacheValue = await _distributedCache.GetAsync <T>(cacheKey); } catch (Exception ex) { _logger?.LogError(ex, "distributed cache get error, [{0}]", cacheKey); } if (cacheValue.HasValue) { TimeSpan ts = await GetExpirationFromDistributedProviderAsync(cacheKey); await _localCache.SetAsync(cacheKey, cacheValue.Value, ts); return(cacheValue); } _logger?.LogDebug("distributed cache can not get the value of {0}", cacheKey); return(CacheValue <T> .NoValue); }
/// <summary> /// Gets the specified cacheKey async. /// </summary> /// <returns>The async.</returns> /// <param name="cacheKey">Cache key.</param> /// <typeparam name="T">The 1st type parameter.</typeparam> public async Task <CacheValue <T> > GetAsync <T>(string cacheKey) { ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); var cacheValue = await _localCache.GetAsync <T>(cacheKey); if (cacheValue.HasValue) { return(cacheValue); } LogMessage($"local cache can not get the value of {cacheKey}"); try { cacheValue = await _distributedCache.GetAsync <T>(cacheKey); } catch (Exception ex) { LogMessage($"distributed cache get error, [{cacheKey}]", ex); } if (cacheValue.HasValue) { TimeSpan ts = await GetExpirationAsync(cacheKey); await _localCache.SetAsync(cacheKey, cacheValue.Value, ts); return(cacheValue); } LogMessage($"distributed cache can not get the value of {cacheKey}"); return(CacheValue <T> .NoValue); }
/// <summary> /// Adds cache with specified key and object /// </summary> public async Task SetAsync(string key, object data, int cacheTime) { if (cacheTime <= 0) { return; } await _provider.SetAsync(key, data, TimeSpan.FromMinutes(cacheTime)); }
/// <summary> /// 获取设置并且同步缓存中的设置 /// </summary> /// <returns></returns> private async Task <List <AppSettingsDto> > GetSettingsFromDBAsync() { var settings = await _dbContext.Settings.Select(s => new AppSettingsDto { Key = s.Key, Value = s.Value }).ToListAsync(); await _cache.SetAsync(Constants.RedisKey.Settings, settings, TimeSpan.FromHours(1)); return(settings); }
public async Task <CustomerBasket> UpdateBasketAsync(CustomerBasket basket) { var content = JsonConvert.SerializeObject(basket); await easyCachingProvider.SetAsync("Basket_" + basket.BuyerId, content, TimeSpan.FromDays(1)); return(await GetBasketAsync(basket.BuyerId)); }
public async Task <Configuration> BuildUserSessionConfiguration(CancellationToken cancellationToken = default) { var id = _httpContextAccessor.HttpContext.GetAuthId(); var session = await _cachingService.GetUserSession(id); if (session.HasValue) { return(new Configuration { AccessToken = session.Value.AccessToken }); } var email = _httpContextAccessor.HttpContext.GetAuthEmail(); var user = await _databaseContext.UserAccounts.AsNoTracking() .FirstOrDefaultAsync(x => x.Email == email, cancellationToken); var finApiSession = await Login(user.Id.ToString(), user.Password, cancellationToken); var newSession = new FinApiSession(finApiSession._AccessToken, finApiSession.RefreshToken); await _cachingProvider.SetAsync(user.Id.ToString(), newSession, TimeSpan.FromHours(finApiSession.ExpiresIn)); return(new Configuration { AccessToken = finApiSession._AccessToken }); }
public async Task <string> GetAsync(string str) { var method = str.ToLower(); switch (method) { case "get": var res = await _provider.GetAsync("demo", async() => await Task.FromResult("456"), TimeSpan.FromMinutes(1)); return($"cached value : {res}"); case "set": await _provider.SetAsync("demo", "123", TimeSpan.FromMinutes(1)); return("seted"); case "remove": await _provider.RemoveAsync("demo"); return("removed"); case "getcount": var count = _provider.GetCount(); return($"{count}"); default: return("default"); } }
public async Task Invoke(HttpContext context) { var cacheKey = context.Request.GenerateCacheKeyFromRequest(); if (!await _easyCachingProvider.ExistsAsync(cacheKey)) { await using var swapStream = new MemoryStream(); var originalResponseBody = context.Response.Body; context.Response.Body = swapStream; await _next(context); swapStream.Seek(0, SeekOrigin.Begin); string responseBody = await new StreamReader(swapStream).ReadToEndAsync(); swapStream.Seek(0, SeekOrigin.Begin); context.Response.Body = originalResponseBody; await _easyCachingProvider.SetAsync(cacheKey, responseBody, TimeSpan.FromMinutes(1)); await context.Response.WriteAsync(responseBody); } else { var cacheValue = await _easyCachingProvider.GetAsync <string>(cacheKey); await context.Response.WriteAsync(cacheValue.Value); } await this._next(context); }
public async Task <IActionResult> GetLanguages() { Language languages = null; var cacheValue = await _cache.GetAsync <Language>(Constants.CacheKey.Languages); if (cacheValue.HasValue) { languages = cacheValue.Value; } if (languages == null) { using (var http = new HttpClient()) { http.Timeout = TimeSpan.FromSeconds(30); http.DefaultRequestHeaders.Add("Accept-Language", "zh-Hans"); var response = await http.GetAsync("https://api.cognitive.microsofttranslator.com/languages?api-version=3.0&scope=translation"); if (response.IsSuccessStatusCode) { var content = await response.Content.ReadAsStringAsync(); languages = JsonConvert.DeserializeObject <Language>(content); await _cache.SetAsync <Language>(Constants.CacheKey.Languages, languages, TimeSpan.FromDays(3)); } } } var translation = languages?.translation?.Select(trans => new { lang = trans.Key, name = trans.Value.Name, nativeName = trans.Value.NativeName }); return(Ok(translation)); }
public async Task <string> GetAsync(int type = 1) { if (type == 1) { await _provider.RemoveAsync("demo"); return("removed"); } else if (type == 2) { await _provider.SetAsync("demo", "123", TimeSpan.FromMinutes(1)); return("seted"); } else if (type == 3) { var res = await _provider.GetAsync("demo", async() => await Task.FromResult("456"), TimeSpan.FromMinutes(1)); return($"cached value : {res}"); } else { return("error"); } }
/// <summary> /// Gets the specified cacheKey async. /// </summary> /// <returns>The async.</returns> /// <param name="cacheKey">Cache key.</param> /// <typeparam name="T">The 1st type parameter.</typeparam> public async Task <CacheValue <T> > GetAsync <T>(string cacheKey) { ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); var cacheValue = await _localCache.GetAsync <T>(cacheKey); if (cacheValue.HasValue) { return(cacheValue); } if (_options.EnableLogging) { _logger.LogTrace($"local cache can not get the value of {cacheKey}"); } cacheValue = await _distributedCache.GetAsync <T>(cacheKey); if (cacheValue.HasValue) { TimeSpan ts = TimeSpan.Zero; try { ts = await _distributedCache.GetExpirationAsync(cacheKey); } catch { } if (ts <= TimeSpan.Zero) { ts = TimeSpan.FromSeconds(_options.DefaultExpirationForTtlFailed); } await _localCache.SetAsync(cacheKey, cacheValue.Value, ts); return(cacheValue); } if (_options.EnableLogging) { _logger.LogTrace($"distributed cache can not get the value of {cacheKey}"); } return(CacheValue <T> .NoValue); }
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args) { await _telegramService.AddUpdateContext(context); var message = _telegramService.Message; await _easyCachingProvider.SetAsync($"message{message.MessageId}", message, TimeSpan.FromMinutes(10)); await _telegramService.SendTextMessageAsync("Pong!"); }
/// <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)); await _localCachingProvider.SetAsync(cacheKey, cacheValue, expiration); await _distributedCachingProvider.SetAsync(cacheKey, cacheValue, expiration); }
public async Task <ApiResult <Cart> > Updatecart(String key, Cart request) { var data = JsonConvert.SerializeObject(request); // var result = Encoding.UTF8.GetBytes(data); //var option = new DistributedCacheEntryOptions() // .SetSlidingExpiration(TimeSpan.FromDays(5)) // .SetAbsoluteExpiration(DateTime.Now.AddDays(6)); await cachingProvider.SetAsync(key, data, TimeSpan.FromDays(100)); return(await GetById(key)); }
private async Task <IEnumerable <AlbumLookupEntry> > GetAllAlbumsInternal(string searchString, CancellationToken token) { _logger.LogInformation(searchString); var client = new RestClient($"https://itunes.apple.com/search?term={searchString}&media=music&entity=album"); var request = new RestRequest(Method.GET); IRestResponse response = await AsyncEx.Retry(() => client.ExecuteAsync(request, token), 3, TimeSpan.FromMilliseconds(100), token); var searchResponse = JsonConvert.DeserializeObject <ApiResponse <AlbumLookupEntry> >(response.Content); await _cachingProvider.SetAsync(searchString, searchResponse.Results, TimeSpan.FromMinutes(ExpirationCacheInMinutes)); return(searchResponse.Results.Where(x => x.CollectionId != null)); }
/// <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)); await _localCache.SetAsync(cacheKey, cacheValue, expiration); await _distributedCache.SetAsync(cacheKey, cacheValue, expiration); //When create/update cache, send message to bus so that other clients can remove it. await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { cacheKey } }); }
public async Task Sec_Set_Value_And_Get_Cached_Value_Async_Should_Succeed() { var cacheKey = Guid.NewGuid().ToString(); var cacheValue = "value"; await _secondProvider.SetAsync(cacheKey, cacheValue, _defaultTs); var val = await _secondProvider.GetAsync <string>(cacheKey); Assert.True(val.HasValue); Assert.Equal(cacheValue, val.Value); }
protected virtual async Task Set_Value_And_Get_Cached_Value_Async_Should_Succeed() { var cacheKey = $"{_nameSpace}{Guid.NewGuid().ToString()}"; var cacheValue = "value"; await _provider.SetAsync(cacheKey, cacheValue, _defaultTs); var val = await _provider.GetAsync <string>(cacheKey); Assert.True(val.HasValue); Assert.Equal(cacheValue, val.Value); }
/// <summary> /// /// </summary> /// <param name="id"></param> /// <param name="policy"></param> /// <returns></returns> public async Task <bool> PutPolicy(string id, Platform.Policy.Models.Policy policy) { var set = false; string methodName = $"{MethodBase.GetCurrentMethod().DeclaringType.FullName.Split('+')[0]}.{MethodBase.GetCurrentMethod().DeclaringType.FullName.Split('+')[1].Split('<', '>')[1]}"; if (policy != null) { set = await _policyRepository.PutPolicy(id, policy); if (set) { await _cacheProvider.SetAsync <Platform.Policy.Models.Policy>(id, policy, TimeSpan.FromMinutes(15)); } else { _logger.Warning($"{methodName}. The metadata/Json passed for policy {id} was invalid"); } } return(set); }
public async Task CatcheResponseAsync(string cacheKey, object response, TimeSpan timeToLive) { try { if (response == null) { return; } var serializeResponse = JsonConvert.SerializeObject(response); await _cachingProvider.SetAsync(cacheKey, serializeResponse, timeToLive); } catch (Exception) { } }
public async Task <CaptchaResultModel> GetCaptcha() { var randomValue = CaptchaHelper.GetValidateCode(5); var imageData = CaptchaHelper.CreateBase64Image(randomValue); var key = Guid.NewGuid().ToString(); await _cachingProvider.SetAsync(key, randomValue, TimeSpan.FromMinutes(2)); return(new CaptchaResultModel { CaptchaKey = key, CaptchaData = imageData }); }
public async Task <T> GetAsync <T>(string key, Func <Task <T> > acquire, int?cacheTime = null) { if (await _provider.ExistsAsync(key)) { return((await _provider.GetAsync <T>(key)).Value); } if ((cacheTime ?? CachingDefaultSettings.CacheTime) > 0) { await _provider.SetAsync(key, acquire, TimeSpan.FromMinutes(cacheTime ?? CachingDefaultSettings.CacheTime)); } return(await acquire()); }
/// <summary> /// 取得缓存数据(异步) /// </summary> /// <returns>数据</returns> public async Task <IList <T> > GetCacheDataAsync() { var cacheList = await _provider.GetAsync <List <T> >(_cacheKey); if (!cacheList.HasValue) { // 全量取出 var dataList = _repository.Get().ToList(); await _provider.SetAsync(_cacheKey, dataList, TimeSpan.FromSeconds(_cachingOption.ExpireSpan)); return(dataList); } return(cacheList.Value); }
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default) { if (key == null) { throw new ArgumentNullException(nameof(key)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } var expiration = GetEasyCacheExpiration(options); _expirations.TryAdd(key, expiration); return(_easyCachingProvider.SetAsync(key, value, expiration)); }
public async Task OnGetAsync() { var productList = await _cachingProvider.GetAsync <List <Product> >("PRODUCT_LIST"); if (productList.IsNull) { var _list = await _dbContext.Products.ToListAsync(); if (_list.Any()) { await _cachingProvider.SetAsync("PRODUCT_LIST", _list, new TimeSpan(0, 1, 0)); } Product = SearchFilter(SearchString, _list); } else { Product = SearchFilter(SearchString, (List <Product>)productList.Value); } }
/// <summary> /// 获取 AccessToken /// </summary> /// <returns></returns> public async Task <string> GetAccessToken() { var cacheToken = (await _provider.GetAsync <string>(CacheKey)).Value; if (!string.IsNullOrEmpty(cacheToken)) { return(cacheToken); } var accessTokenResponse = await GetAccessTokenFromApi(); if (accessTokenResponse.HasError()) { throw new Exception(accessTokenResponse.ErrorMessage); } var accessToken = accessTokenResponse.AccessToken; await _provider.SetAsync(CacheKey, accessToken, ExpireIn); return(accessToken); }
public async Task <List <JobInfo> > GetJobsAsync(int?minutes = null) { var cache = GetCacheObject(); if (cache != null && cache.Count > 0) { return(cache); } var cityCode = CodesData.GetCityCode(Recruit, this.City); var data = await GetJobsFromWeb(cityCode); var time = minutes ?? 10; //缓存10分钟 await _provider.SetAsync(CacheKey, data, TimeSpan.FromMinutes(time)); return(data); }