private async Task <IEnumerable <ProxyDatabaseResult> > FetchResults(ulong account, ICacheEntry entry) { _logger.Information("Members for account {Account} not in cache, fetching", account); using (var conn = await _conn.Obtain()) { var results = (await conn.QueryAsync <PKMember, PKSystem, ProxyDatabaseResult>( "select members.*, systems.* from members, systems, accounts where members.system = systems.id and accounts.system = systems.id and accounts.uid = @Uid", (member, system) => new ProxyDatabaseResult { Member = member, System = system }, new { Uid = account })).ToList(); if (results.Count == 0) { // Long expiry for accounts with no system registered entry.SetSlidingExpiration(TimeSpan.FromMinutes(5)); entry.SetAbsoluteExpiration(TimeSpan.FromHours(1)); } else { // Shorter expiry if they already have a system entry.SetSlidingExpiration(TimeSpan.FromMinutes(1)); entry.SetAbsoluteExpiration(TimeSpan.FromMinutes(5)); } return(results); } }
private async Task <IEnumerable <Prize> > FetchPrizes(ICacheEntry arg) { arg.SetAbsoluteExpiration(TimeSpan.FromMinutes(5)); arg.SetSlidingExpiration(TimeSpan.FromSeconds(30)); return(await FetchPrizes()); }
public ICacheEntry CreateEntry(object key) { if (key is null) { throw new ArgumentNullException(nameof(key)); } if (_cacheConfiguration.Enabled) { ICacheEntry entry = _memoryCache.CreateEntry(new CacheEntryKey(_name, key)); if (_cacheConfiguration.Expiry.Type == CacheExpiryType.Absolute) { entry.SetAbsoluteExpiration(_cacheConfiguration.Expiry.TTL); } else if (_cacheConfiguration.Expiry.Type == CacheExpiryType.Sliding) { entry.SetSlidingExpiration(_cacheConfiguration.Expiry.TTL); } return(entry); } return(new CacheEntry(key)); }
/// <summary> /// 设置 动态程序集滑动过期时间 10 秒 /// </summary> /// <param name="entry"></param> /// <param name="type"></param> internal static void SetDynamicAssemblyPolicy(this ICacheEntry entry, Type?type) { if (type?.Assembly.IsDynamic ?? false) { entry.SetSlidingExpiration(TimeSpan.FromSeconds(10)); } }
Task <Song> GenerateCacheEntry(ICacheEntry cacheEntry, uint songID, CancellationToken cancellation) { lock (cacheEntry) { if (cacheEntry.Value is Task <Song> generating) { return(generating); } else { cacheEntry.SetSlidingExpiration(TimeSpan.FromHours(24)); Task <Song> result = this.FetchOrGenerateSong(songID, cancellation); cacheEntry.SetAbsoluteExpiration(TimeSpan.FromDays(7)); cacheEntry.Value = result; cacheEntry.Dispose(); result.ContinueWith(songTask => { if (!songTask.IsCompletedSuccessfully) { return; } Song song = songTask.Result; cacheEntry.SetSize( song.Title?.Length + song.Lyrics?.Length + song.GeneratorError?.Length ?? 64); }); return(result); } } }
private async Task <T> CacheFromApi <T>(Uri uri, ICacheEntry entry, CancellationToken cancellationToken) { var @object = await GetFromApi <T>(uri, cancellationToken) .ConfigureAwait(false); entry .SetSlidingExpiration(TimeSpan.FromHours(1)) .SetValue(@object); return(@object); }
private async Task <OSM> CreateCache(int id, ICacheEntry entry, DateTime?dateTime) { entry.SetSlidingExpiration(TimeSpan.FromMinutes(15)); var text = await GetRelationFromOSMAsync(id, dateTime); if (text == null) { return(null); } var osm = JsonConvert.DeserializeObject <OSM>(text.ToString()); return(osm); }
private void SetExpiration(ICacheEntry entry, CancellationTokenSource tokenSourceBeforeComputingValue, double inMinutes, Action <ICacheEntry>?configureEntry = null) { lock (_tokenSourceSync) { configureEntry?.Invoke(entry); if (tokenSourceBeforeComputingValue != ClearCacheTokenSource) { entry.SetAbsoluteExpiration(TimeSpan.FromTicks(1)); } else { entry.SetSlidingExpiration(TimeSpan.FromMinutes(inMinutes)) .AddExpirationToken(new CancellationChangeToken(ClearCacheTokenSource.Token)); } } }
private async Task <ISchema> Create(ICacheEntry cacheEntry) { cacheEntry.SetSlidingExpiration(TimeSpan.FromHours(6)); try { // create channelsSchema by introspecting channels service var channelsLink = Links.SignalROrHttp( _configuration["Remotes:Channels"], _configuration["Remotes:ChannelsHttp"], _accessor); var channelsSchema = RemoteSchemaTools.MakeRemoteExecutable( await new SchemaBuilder() .ImportIntrospectedSchema(channelsLink), channelsLink); // create messagesSchema by introspecting messages service var messagesLink = Links.SignalR( _configuration["Remotes:Messages"], _accessor); var messagesSchema = RemoteSchemaTools.MakeRemoteExecutable( await new SchemaBuilder() .ImportIntrospectedSchema(messagesLink), messagesLink); // combine schemas into one var schema = new SchemaBuilder() .Merge(channelsSchema, messagesSchema) .Build(); // introspect and merge with schema var introspection = Introspect.Schema(schema); return(new SchemaBuilder() .Merge(schema, introspection) .Build()); } catch (Exception e) { Console.WriteLine(e); throw; } }
/// <summary> /// Adds an object to distributed cache /// </summary> /// <param name="key">Cache Key</param> /// <param name="value">Cache object</param> /// <param name="options">Distributed cache options. <see cref="ExtendedDistributedCacheEntryOptions"/></param> public void Set(string key, byte[] value, ExtendedDistributedCacheEntryOptions options) { if (key == null) { throw new ArgumentNullException(nameof(key)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } using (ICacheEntry cacheEntry = CreateEntry(key)) { var memoryCacheEntryOptions = GetMemoryCacheEntryOptions(options, value.LongLength); cacheEntry.SetOptions(memoryCacheEntryOptions); if (memoryCacheEntryOptions.AbsoluteExpiration != null) { cacheEntry.SetAbsoluteExpiration(memoryCacheEntryOptions.AbsoluteExpiration.Value); } if (memoryCacheEntryOptions.AbsoluteExpirationRelativeToNow != null) { cacheEntry.SetAbsoluteExpiration(memoryCacheEntryOptions.AbsoluteExpirationRelativeToNow.Value); } if (memoryCacheEntryOptions.SlidingExpiration != null) { cacheEntry.SetSlidingExpiration(memoryCacheEntryOptions.SlidingExpiration.Value); } cacheEntry.SetPriority(memoryCacheEntryOptions.Priority); cacheEntry.SetSize(value.LongLength); cacheEntry.SetValue(value); } }
private async Task <ISchema> Create(ICacheEntry cacheEntry) { cacheEntry.SetSlidingExpiration(TimeSpan.FromHours(6)); try { var schemaBuilder = await SchemaLoader.Load(); var resolvers = new SchemaResolvers(); var schema = SchemaTools.MakeExecutableSchemaWithIntrospection( schemaBuilder, resolvers, resolvers); return(schema); } catch (Exception e) { Console.WriteLine(e); throw; } }
/// <summary> /// Sets the default cache entry options. /// </summary> public static ICacheEntry SetDefaultOptions(this ICacheEntry cacheEntry, IWebContext webContext) { cacheEntry.SetSlidingExpiration(CacheExpiration); cacheEntry.AddExpirationToken(webContext); return(cacheEntry); }
private async Task <List <OSMLineDTO> > CreateCacheLinesNetwork(string network, DateTime?dateTime, ICacheEntry entry) { entry.SetSlidingExpiration(TimeSpan.FromMinutes(15)); return(await CreateNetworkRoutesListAsync(network, dateTime)); }
private async Task <List <OSMLineDTO> > CreateCacheLines(string reference, OSMRouteType?routeType, string network, ICacheEntry entry, DateTime?dateTime) { entry.SetSlidingExpiration(TimeSpan.FromMinutes(15)); return(await CreateRoutesListAsync(reference, routeType, network, dateTime)); }
void SetupCacheEntry(ICacheEntry cacheEntry) { cacheEntry.SetSize(_cacheSize); cacheEntry.SetSlidingExpiration(_slidingExpirationTime); cacheEntry.SetAbsoluteExpiration(_absoluteExpirationTime); }