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