internal TableCacheEntity(string partitionKey, string rowKey, byte[] data = null, DistributedCacheEntryOptions options = null) : base(partitionKey, rowKey) { DateTimeOffset utcNow = DateTimeOffset.UtcNow; if (options?.AbsoluteExpirationRelativeToNow != null) { AbsoluteExpiration = utcNow.Add(options.AbsoluteExpirationRelativeToNow.Value); } else if (options?.AbsoluteExpiration != null) { if (options.AbsoluteExpiration <= utcNow) { throw new ArgumentOutOfRangeException(nameof(options.AbsoluteExpiration), options.AbsoluteExpiration.Value, "Absolute expiration value must be in the future."); } AbsoluteExpiration = options.AbsoluteExpiration; } Data = data; SlidingExpiration = options?.SlidingExpiration; LastAccessedTime = utcNow; }
public async Task SetManyAsync(IEnumerable <KeyValuePair <string, byte[]> > items, DistributedCacheEntryOptions options, CancellationToken token = default) { foreach (var item in items) { await SetAsync(item.Key, item.Value, options, token); } }
public static void Set <T>(this IDistributedCache cache, string key, T value, DistributedCacheEntryOptions options) { byte[] bytes; using (var memoryStream = new MemoryStream()) { var binaryFormatter = new BinaryFormatter(); binaryFormatter.Serialize(memoryStream, value); bytes = memoryStream.ToArray(); } cache.Set(key, bytes, options); }
/// <summary> /// This method is used to set an object into cache as a JSON converted string. /// </summary> /// <param name="cache">Contains the cache to extend.</param> /// <param name="key">Contains the key of the cache item to set.</param> /// <param name="item">Contains the item to convert to JSON.</param> /// <param name="options">Contains an optional cache entry options.</param> /// <param name="token">Contains an optional cancellation token.</param> /// <returns></returns> public static async Task SetJsonAsync(this IDistributedCache cache, string key, object item, DistributedCacheEntryOptions options = null, CancellationToken token = default) { string content = JsonConvert.SerializeObject(item); await cache.SetStringAsync(key, content, options, token); }
public void Set(string key, byte[] value, DistributedCacheEntryOptions options) { throw new NotImplementedException(); }
/// <summary> /// 获取指定键的缓存项,不存在则从指定委托获取,并回存到缓存中再返回 /// </summary> public static TResult Get <TResult>(this IDistributedCache cache, string key, Func <TResult> getFunc, DistributedCacheEntryOptions options = null) { TResult result = cache.Get <TResult>(key); if (!Equals(result, default(TResult))) { return(result); } result = getFunc(); if (Equals(result, default(TResult))) { return(default(TResult)); } cache.Set(key, result, options); return(result); }
/// <summary> /// 异步将对象存入缓存中 /// </summary> public static async Task SetAsync(this IDistributedCache cache, string key, object value, DistributedCacheEntryOptions options = null) { Check.NotNullOrEmpty(key, nameof(key)); Check.NotNull(value, nameof(value)); string json = value.ToJsonString(); if (options == null) { await cache.SetStringAsync(key, json); } else { await cache.SetStringAsync(key, json, options); } }
public static async Task SetObject( this IDistributedCache distributedCache, string key, object value, DistributedCacheEntryOptions options) { await distributedCache.SetAsync(key, value.ToByteArray(), options); }
public static async Task SetObjectAsync(this IDistributedCache cache, string key, object value, DistributedCacheEntryOptions options) { var json = JsonConvert.SerializeObject(value, _serializerSettings); await cache.SetStringAsync(key, json, options); }
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options) { return(base.SetAsync(key, value, new DistributedCacheEntryOptions())); }
public DistributedCacheValueTypeExtensionsTest() { _cache = new FakeDistributedCache(); _option = new DistributedCacheEntryOptions(); }
public void Set(string key, byte[] value, DistributedCacheEntryOptions options) { base.Set(key, value, new DistributedCacheEntryOptions()); }
public void Intercept(IInvocation invocation) { Console.WriteLine("执行前..."); // 判断当前方法是否包含 IgnoreCache 特性 var method = invocation.GetConcreteMethod(); // 调用的具体方法,接口、具体类 var targetMethod = invocation.GetConcreteMethodInvocationTarget(); // 获取具体的调用目标方法,也就是实际执行的方法 // 忽略缓存 var ignoreAttr = this.GetAttribute <IgnoreCacheAttribute>(method, targetMethod); if (ignoreAttr != null) { Console.WriteLine("忽略缓存..."); // 执行原本方法 invocation.Proceed(); return; } Console.WriteLine("读取本地缓存..."); // 本地缓存配置 var memoryOptions = this.GetAttribute <MemoryCacheOptionsAttribute>(method, targetMethod); // 生成缓存 key var memoryCacheKey = this.GenericCacheKey(invocation, memoryOptions.KeyPrefix); // Redis缓存获取 var redisOptions = this.GetAttribute <RedisCacheOptionsAttribute>(method, targetMethod); // 读取本地缓存 var cacheValue = _memoryCache.Get(memoryCacheKey); if (cacheValue == null) { Console.WriteLine("读取Redis缓存..."); // 生成缓存 key var redisCacheKey = this.GenericCacheKey(invocation, redisOptions.KeyPrefix); cacheValue = _distributedCache.Get(redisCacheKey); } if (cacheValue != null) { Console.WriteLine("读取缓存..."); //将当前获取到的缓存值,赋值给当前执行方法 invocation.ReturnValue = cacheValue; return; } // 执行原本方法 invocation.Proceed(); //存入缓存 if (!string.IsNullOrWhiteSpace(memoryCacheKey)) { Console.WriteLine("写入本地缓存..."); // 写入本地缓存 var entryOptions = new MemoryCacheEntryOptions() .SetSize(1) // (TimeSpan.FromSeconds((double)memoryOptions.AbsoluteExpiration)) .SetSlidingExpiration(TimeSpan.FromSeconds((double)memoryOptions.SlidingExpiration)); if (memoryOptions.AbsoluteExpiration > 0) { entryOptions.SetAbsoluteExpiration(DateTime.Now.AddSeconds((double)memoryOptions.AbsoluteExpiration)); } _memoryCache.Set(memoryCacheKey, invocation.ReturnValue, entryOptions); Console.WriteLine("写入Redis缓存..."); // 写入Redis缓存 var redisEntryOptions = new DistributedCacheEntryOptions() { SlidingExpiration = TimeSpan.FromSeconds((double)redisOptions.SlidingExpiration) }; if (redisOptions.AbsoluteExpiration > 0) { redisEntryOptions.SetAbsoluteExpiration(DateTime.Now.AddSeconds((double)redisOptions.AbsoluteExpiration)); } _distributedCache.SetString(memoryCacheKey, System.Text.Json.JsonSerializer.Serialize(invocation.ReturnValue), redisEntryOptions); } Console.WriteLine("执行后..."); }
public static Task SetAsync <TValue>(this IDistributedCache cache, TValue value, string[] keys, DistributedCacheEntryOptions options, CancellationToken cancellationToken = new())
private static DateTimeOffset?GetAbsoluteExpiration(DateTimeOffset creationTime, DistributedCacheEntryOptions options) { if (options.AbsoluteExpiration.HasValue && options.AbsoluteExpiration <= creationTime) { throw new ArgumentOutOfRangeException( nameof(DistributedCacheEntryOptions.AbsoluteExpiration), options.AbsoluteExpiration.Value, "The absolute expiration value must be in the future."); } var absoluteExpiration = options.AbsoluteExpiration; if (options.AbsoluteExpirationRelativeToNow.HasValue) { absoluteExpiration = creationTime + options.AbsoluteExpirationRelativeToNow; } return(absoluteExpiration); }
public async static Task SetAsync <T>(this IDistributedCache distributedCache, string key, T value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken)) { await distributedCache.SetAsync(key, value.ToByteArray(), options, token); }
public RedisCacheManager(IDistributedCache cache, DistributedCacheEntryOptions options, RedisConnection redisConnection) { _redisConnection = redisConnection; _options = options; _distributedCache = cache; }
public CacheServicesDistributedCache(IDistributedCache distributedCache, DistributedCacheEntryOptions cacheOptions) { _distributedCache = distributedCache; _cacheOptions = cacheOptions; }
/// <summary> /// 异步获取指定键的缓存项,不存在则从指定委托获取,并回存到缓存中再返回 /// </summary> public static async Task <TResult> GetAsync <TResult>(this IDistributedCache cache, string key, Func <Task <TResult> > getAsyncFunc, DistributedCacheEntryOptions options = null) { TResult result = await cache.GetAsync <TResult>(key); if (!Equals(result, default(TResult))) { return(result); } result = await getAsyncFunc(); if (Equals(result, default(TResult))) { return(default(TResult)); } await cache.SetAsync(key, result, options); return(result); }
public static Task SetAsync <T>(this IDistributedCache cache, string key, T value, DistributedCacheEntryOptions options, CancellationToken cancellationToken = default) { var serialized = JsonSerializer.Serialize(value); var bytes = Encoding.UTF8.GetBytes(serialized); return(cache.SetAsync(key, bytes, options, cancellationToken)); }
/// <summary> /// This method is used to set an object into cache as a JSON converted string. /// </summary> /// <param name="cache">Contains the cache to extend.</param> /// <param name="key">Contains the key of the cache item to set.</param> /// <param name="item">Contains the item to convert to JSON.</param> /// <param name="options">Contains an optional cache entry options.</param> /// <returns></returns> public static void SetJson(this IDistributedCache cache, string key, object item, DistributedCacheEntryOptions options = null) { string content = JsonConvert.SerializeObject(item); cache.SetString(key, content, options); }
public void Set(string key, byte[] value, DistributedCacheEntryOptions options) { SetAsync(key, value, options).Wait(); }
} //TODO: use a configurator interface instead? public PlusDistributedCacheOptions() { CacheConfigurators = new List <Func <string, DistributedCacheEntryOptions> >(); GlobalCacheEntryOptions = new DistributedCacheEntryOptions(); KeyPrefix = ""; }
/// <summary> /// Configures depdendency injection. /// </summary> /// <param name="services">The service collection.</param> public void ConfigureServices(IServiceCollection services) { switch (NeonBlazorProxyService.Config.Cache.Backend) { case CacheType.InMemory: services.AddDistributedMemoryCache(); break; case CacheType.Redis: services.AddStackExchangeRedisCache(options => { NeonBlazorProxyService.Config.Cache.Redis.GetOptions(); }); break; default: services.AddDistributedMemoryCache(); break; } services.AddSingleton(NeonBlazorProxyService); services.AddSingleton(NeonBlazorProxyService.Config); services.AddSingleton <INeonLogger>(NeonBlazorProxyService.Log); services.AddSingleton(NeonBlazorProxyService.DnsClient); services.AddHealthChecks(); services.AddHttpForwarder(); services.AddHttpClient(); services.AddAllPrometheusMetrics(); // Http client for Yarp. services.AddSingleton <HttpMessageInvoker>( serviceProvider => { return(new HttpMessageInvoker(new SocketsHttpHandler() { UseProxy = false, AllowAutoRedirect = false, AutomaticDecompression = DecompressionMethods.None, UseCookies = false, ActivityHeadersPropagator = new ReverseProxyPropagator(DistributedContextPropagator.Current) })); }); // Cookie encryption cipher. services.AddSingleton(NeonBlazorProxyService.AesCipher); var cacheOptions = new DistributedCacheEntryOptions() { AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(NeonBlazorProxyService.Config.Cache.DurationSeconds) }; services.AddSingleton(cacheOptions); services.AddSingleton <SessionTransformer>( serviceProvider => { return(new SessionTransformer(serviceProvider.GetService <IDistributedCache>(), NeonBlazorProxyService.Log, cacheOptions, NeonBlazorProxyService.AesCipher)); }); services.AddControllers() .AddNeon(); }
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken)) { throw new NotImplementedException(); }
public override async Task <IEnumerable <Price> > GetOrSetValueAsync(string key, Func <Task <IEnumerable <Price> > > valueDelegate, DistributedCacheEntryOptions options = null) { //call the base class' method with the clarified caching options return(await base.GetOrSetValueAsync(key, valueDelegate, options)); }
public static Task SetAsync <T>(this IDistributedCache cache, string key, T value, DistributedCacheEntryOptions options) { byte[] bytes; using (var memoryStream = new MemoryStream()) { var binaryFormatter = new BinaryFormatter(); binaryFormatter.Serialize(memoryStream, value); bytes = memoryStream.ToArray(); } key.Replace(" ", string.Empty); return(cache.SetAsync(key, bytes, options)); }
private static long?GetExpirationInSeconds(DateTimeOffset creationTime, DateTimeOffset?absoluteExpiration, DistributedCacheEntryOptions options) { if (absoluteExpiration.HasValue && options.SlidingExpiration.HasValue) { return((long)Math.Min( (absoluteExpiration.Value - creationTime).TotalSeconds, options.SlidingExpiration.Value.TotalSeconds)); } else if (absoluteExpiration.HasValue) { return((long)(absoluteExpiration.Value - creationTime).TotalSeconds); } else if (options.SlidingExpiration.HasValue) { return((long)options.SlidingExpiration.Value.TotalSeconds); } return(null); }
private void CreateBulkInsert(DbCommand cmd, IEnumerable <KeyValuePair <string, byte[]> > keyValues, DistributedCacheEntryOptions options) { StringBuilder sb = new StringBuilder(); sb.AppendLine(DbCommands.Commands[(int)Operation.BulkInsert]); int i = 0; foreach (var pair in keyValues) { sb.Append($"(@key{i}, @value{i}, @expiry, @renewal),"); cmd.Parameters.AddWithValue($"@key{i}", pair.Key); cmd.Parameters.AddWithValue($"@value{i}", pair.Value); i++; } sb.Remove(sb.Length - 1, 1); sb.Append(";"); AddExpirationParameters(cmd, options); cmd.CommandText = sb.ToString(); }
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default) => _distributedCache.SetAsync(key, value, options, token);