public void Set(string route, OutputCacheResponseEntry entry, HttpContext context) { if (!context.IsOutputCachingEnabled(out OutputCacheProfile profile)) { return; } var env = (IHostingEnvironment)context.RequestServices.GetService(typeof(IHostingEnvironment)); var options = new MemoryCacheEntryOptions(); if (profile.UseAbsoluteExpiration) { options.SetAbsoluteExpiration(TimeSpan.FromSeconds(profile.Duration)); } else { options.SetSlidingExpiration(TimeSpan.FromSeconds(profile.Duration)); } foreach (string globs in profile.FileDependencies) { options.AddExpirationToken(env.ContentRootFileProvider.Watch(globs)); } string cleanRoute = NormalizeRoute(route); _cache.Set(cleanRoute, entry, options); }
private ViewLocationCacheResult LocatePageFromPath(string executingFilePath, string pagePath, bool isMainPage) { var applicationRelativePath = GetAbsolutePath(executingFilePath, pagePath); var cacheKey = new ViewLocationCacheKey(applicationRelativePath, isMainPage); if (!ViewLookupCache.TryGetValue(cacheKey, out ViewLocationCacheResult cacheResult)) { var expirationTokens = new HashSet <IChangeToken>(); cacheResult = CreateCacheResult(expirationTokens, applicationRelativePath, isMainPage); var cacheEntryOptions = new MemoryCacheEntryOptions(); cacheEntryOptions.SetSlidingExpiration(_cacheExpirationDuration); foreach (var expirationToken in expirationTokens) { cacheEntryOptions.AddExpirationToken(expirationToken); } // No views were found at the specified location. Create a not found result. if (cacheResult == null) { cacheResult = new ViewLocationCacheResult(new[] { applicationRelativePath }); } cacheResult = ViewLookupCache.Set( cacheKey, cacheResult, cacheEntryOptions); } return(cacheResult); }
/// <summary> /// sets the cache entry T /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <param name="value"></param> /// <param name="expirationInMinutes"></param> /// <returns></returns> public T Set <T>(object key, T value, int expirationInMinutes = 60) { var options = new MemoryCacheEntryOptions().SetPriority(CacheItemPriority.Normal).SetAbsoluteExpiration(TimeSpan.FromMinutes(expirationInMinutes)); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); _memoryCache.Set(key, value, options); return(value); }
private MemoryCacheEntryOptions GetMemoryCacheEntryOptions() { var options = new MemoryCacheEntryOptions(); options.AddExpirationToken(new CancellationChangeToken(CancellationToken.None)); return(options); }
private TItem Set <TItem>(IMemoryCache cache, object key, TItem value, MemoryCacheEntryOptions options, CancellationTokenSource token) { MemoryCacheEntryOptions opt = options ?? new MemoryCacheEntryOptions().SetPriority(CacheItemPriority.Normal); opt.AddExpirationToken(new CancellationChangeToken(token.Token)); return(cache.Set(key, value, opt)); }
public void Set <T>(string key, T value) { var options = new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(this._apiSetting.Interval)); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); _memoryCache.Set(key, value); }
/// <summary> /// Prepare cache entry options for the passed key /// </summary> /// <returns>Cache entry options</returns> private MemoryCacheEntryOptions PrepareEntryOptions(string key, int cacheTime) { //set expiration time for the passed cache key var options = new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(cacheTime) }; //add tokens to clear cache entries options.AddExpirationToken(new CancellationChangeToken(_clearToken.Token)); var tokenSource = _keys.GetOrAdd(key, new CancellationTokenSource()); options.AddExpirationToken(new CancellationChangeToken(tokenSource.Token)); return(options); }
private MemoryCacheEntryOptions GetMemoryCacheEntryOptions(string relativePath) { var options = new MemoryCacheEntryOptions(); options.AddExpirationToken(_fileProvider.Watch(relativePath)); return(options); }
private void UpdateReset(string name) { var mo = new MemoryCacheEntryOptions(); mo.RegisterPostEvictionCallback(this.PostEvictionCallback); mo.AddExpirationToken( new CancellationChangeToken(new CancellationTokenSource(ResetCacheTimeout).Token)); this.cache.Set($"feeds:reset:<{name}>", DateTime.Now, mo); }
/* other method and ctor removed for brevity */ public T Set <T>(object key, T value) { /* some other code removed for brevity */ var options = new MemoryCacheEntryOptions().SetPriority(CacheItemPriority.Normal).SetAbsoluteExpiration(typeExpiration); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); _innerCache.Set(CreateKey(type, key), value, options); return(value); }
/// <summary> /// Prepare cache entry options for the passed key /// </summary> /// <param name="key">Cache key</param> /// <returns>Cache entry options</returns> private MemoryCacheEntryOptions PrepareEntryOptions(CacheKey key) { //set expiration time for the passed cache key var options = new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(key.CacheTime) }; //add tokens to clear cache entries options.AddExpirationToken(new CancellationChangeToken(_clearToken.Token)); foreach (var keyPrefix in key.Prefixes.ToList()) { var tokenSource = _prefixes.GetOrAdd(keyPrefix, new CancellationTokenSource()); options.AddExpirationToken(new CancellationChangeToken(tokenSource.Token)); } return(options); }
public override void Set(DocumentInfo info) { var options = new MemoryCacheEntryOptions() .SetPriority(CacheItemPriority.NeverRemove); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); Cache.Set(CacheOf(info), Serializer.Serialize(info), options); }
public void SetData <T>(string cacheName, string cacheKey, T data, MemoryCacheEntryOptions options) { if (!string.IsNullOrWhiteSpace(cacheName) && options != null) { var cts = CacheTokenManager.Instance.GetCacheToken(cacheName); options.AddExpirationToken(new CancellationChangeToken(cts.Token)); } _memoryCache.Set <T>(cacheKey, data, options); }
private ViewLocationCacheResult OnCacheMiss( ViewLocationExpanderContext expanderContext, ViewLocationCacheKey cacheKey) { var viewLocations = GetViewLocationFormats(expanderContext); var expanders = _options.ViewLocationExpanders; // Read interface .Count once rather than per iteration var expandersCount = expanders.Count; for (var i = 0; i < expandersCount; i++) { viewLocations = expanders[i].ExpandViewLocations(expanderContext, viewLocations); } ViewLocationCacheResult?cacheResult = null; var searchedLocations = new List <string>(); var expirationTokens = new HashSet <IChangeToken>(); foreach (var location in viewLocations) { var path = string.Format( CultureInfo.InvariantCulture, location, expanderContext.ViewName, expanderContext.ControllerName, expanderContext.AreaName); path = ViewEnginePath.ResolvePath(path); cacheResult = CreateCacheResult(expirationTokens, path, expanderContext.IsMainPage); if (cacheResult != null) { break; } searchedLocations.Add(path); } // No views were found at the specified location. Create a not found result. if (cacheResult == null) { cacheResult = new ViewLocationCacheResult(searchedLocations); } var cacheEntryOptions = new MemoryCacheEntryOptions(); cacheEntryOptions.SetSlidingExpiration(_cacheExpirationDuration); foreach (var expirationToken in expirationTokens) { cacheEntryOptions.AddExpirationToken(expirationToken); } ViewLookupCache.Set(cacheKey, cacheResult, cacheEntryOptions); return(cacheResult); }
public void Set(string key, object value, ICacheEntryOptions options) { var _options = new MemoryCacheEntryOptions() { AbsoluteExpiration = options.AbsoluteExpiration, AbsoluteExpirationRelativeToNow = options.AbsoluteExpirationRelativeToNow, SlidingExpiration = options.SlidingExpiration }; _options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); _client.Set(key, value, _options); _keys.Add(key); }
/// <summary> /// Adds string value to memory cache. /// </summary> protected void AddToCache(string cacheKey, string value, IFileProvider fileProvider, params string[] files) { var cacheOptions = new MemoryCacheEntryOptions(); foreach (string file in files) { cacheOptions.AddExpirationToken(fileProvider.Watch(file)); } Cache.Set(cacheKey, value, cacheOptions); }
public void Set(string key, CultureInfo culture, string value) { key = GetCacheKey(key, culture); var options = new MemoryCacheEntryOptions() .SetPriority(CacheItemPriority.Normal) .SetSlidingExpiration(_settings.CacheExpirationOffset); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); _innerCache.Set(key, value, options); }
private IReadOnlyList <string> ExpandGlobbedUrl(string include, string exclude) { if (string.IsNullOrEmpty(include)) { return(Array.Empty <string>()); } var cacheKey = new GlobbingUrlKey(include, exclude); if (Cache.TryGetValue(cacheKey, out List <string> files)) { return(files); } var includeTokenizer = new StringTokenizer(include, PatternSeparator); var includeEnumerator = includeTokenizer.GetEnumerator(); if (!includeEnumerator.MoveNext()) { return(Array.Empty <string>()); } var options = new MemoryCacheEntryOptions(); var trimmedIncludePatterns = new List <string>(); foreach (var includePattern in includeTokenizer) { var changeToken = FileProvider.Watch(includePattern.Value); options.AddExpirationToken(changeToken); trimmedIncludePatterns.Add(NormalizePath(includePattern)); } var matcher = MatcherBuilder != null?MatcherBuilder() : new Matcher(); matcher.AddIncludePatterns(trimmedIncludePatterns); if (!string.IsNullOrWhiteSpace(exclude)) { var excludeTokenizer = new StringTokenizer(exclude, PatternSeparator); var trimmedExcludePatterns = new List <string>(); foreach (var excludePattern in excludeTokenizer) { trimmedExcludePatterns.Add(NormalizePath(excludePattern)); } matcher.AddExcludePatterns(trimmedExcludePatterns); } var(matchedUrls, sizeInBytes) = FindFiles(matcher); options.SetSize(sizeInBytes); return(Cache.Set( cacheKey, matchedUrls, options)); }
public override void Set(DocumentMeta meta, int expire) { var expiration = TimeSpan.FromMinutes(expire); var options = new MemoryCacheEntryOptions() .SetPriority(CacheItemPriority.Normal) .SetAbsoluteExpiration(expiration); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); Cache.Set(CacheOf(meta), Serializer.Serialize(meta), options); }
private ViewLocationCacheResult OnCacheMiss( ViewLocationExpanderContext expanderContext, ViewLocationCacheKey cacheKey) { // Only use the area view location formats if we have an area token. IEnumerable <string> viewLocations = !string.IsNullOrEmpty(expanderContext.AreaName) ? AreaViewLocationFormats : ViewLocationFormats; for (var i = 0; i < _options.ViewLocationExpanders.Count; i++) { viewLocations = _options.ViewLocationExpanders[i].ExpandViewLocations(expanderContext, viewLocations); } ViewLocationCacheResult cacheResult = null; var searchedLocations = new List <string>(); var expirationTokens = new HashSet <IChangeToken>(); var template = expanderContext.ActionContext.HttpContext.RequestServices.GetService <TemplateManager>(); foreach (var location in viewLocations) { var path = string.Format( CultureInfo.InvariantCulture, location, expanderContext.ViewName, expanderContext.ControllerName, template.Current.Identifier, expanderContext.AreaName); cacheResult = CreateCacheResult(expirationTokens, path, expanderContext.IsMainPage); if (cacheResult != null) { break; } searchedLocations.Add(path); } // No views were found at the specified location. Create a not found result. if (cacheResult == null) { cacheResult = new ViewLocationCacheResult(searchedLocations); } var cacheEntryOptions = new MemoryCacheEntryOptions(); cacheEntryOptions.SetSlidingExpiration(_cacheExpirationDuration); foreach (var expirationToken in expirationTokens) { cacheEntryOptions.AddExpirationToken(expirationToken); } return(ViewLookupCache.Set <ViewLocationCacheResult>(cacheKey, cacheResult, cacheEntryOptions)); }
public void Set <TCachedObject>(string key, TCachedObject value, uint secondsCacheTime) { var options = new MemoryCacheEntryOptions() .SetPriority(CacheItemPriority.Normal) .SetAbsoluteExpiration(TimeSpan.FromSeconds(secondsCacheTime)); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); _memoryCache.Set(key, value, options); CacheKeys.Add(key); }
public override void Set <T>(DocumentQuery query, T data) { var expiration = TimeSpan.FromMinutes(query.CacheOf.Expire); var options = new MemoryCacheEntryOptions() .SetPriority(CacheItemPriority.Normal) .SetAbsoluteExpiration(expiration); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); Cache.Set(CacheOf(query), data, options); }
public void Set(string key, object value, int timeInSeconds) { if (timeInSeconds <= 0) { return; } var cacheEntryOptions = new MemoryCacheEntryOptions() .SetSlidingExpiration(TimeSpan.FromSeconds(timeInSeconds)); cacheEntryOptions.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); _memoryCache.Set(key, value, cacheEntryOptions); }
public async Task CacheBasicBehaviorAsync() { var invoked = 0; string ExpensiveComputation(string argument) { invoked++; return("Hello " + argument); } using var cache = new MemoryCache(new MemoryCacheOptions()); using var expireKey1 = new CancellationTokenSource(); var options = new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(10) }; options.AddExpirationToken(new CancellationChangeToken(expireKey1.Token)); var result0 = await cache.AtomicGetOrCreateAsync( "key1", options, () => Task.FromResult(ExpensiveComputation("World!"))); var result1 = await cache.AtomicGetOrCreateAsync( "key2", new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(10) }, () => Task.FromResult(ExpensiveComputation("Loving Wife!"))); var result2 = await cache.AtomicGetOrCreateAsync( "key1", new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(10) }, () => Task.FromResult(ExpensiveComputation("World!"))); Assert.Equal(result0, result2); Assert.NotEqual(result0, result1); Assert.Equal(2, invoked); // Make sure key1 expired. expireKey1.Cancel(); var result3 = await cache.AtomicGetOrCreateAsync( "key1", new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(10) }, () => Task.FromResult(ExpensiveComputation("Foo!"))); var result4 = await cache.AtomicGetOrCreateAsync( "key2", new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(10) }, () => Task.FromResult(ExpensiveComputation("Bar!"))); Assert.Equal(result1, result4); Assert.NotEqual(result0, result3); Assert.Equal(3, invoked); }
protected T GetCached <T>(Func <T> create, string key = null) { var options = new MemoryCacheEntryOptions(); options.SetSlidingExpiration(TimeSpan.FromMinutes(60)); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); return(memoryCache.GetOrCreate(key ?? typeof(T).ToString(), entry => { try { entry.SetOptions(options); } catch { }//moq catch return create.Invoke(); })); }
private async Task <User> PrepareUserResultAsync(MemoryCacheEntryOptions options, AutoRestClients.PlatformModuleApi.Models.ApplicationUserExtended userDto) { if (userDto != null) { var user = userDto.ToUser(); var orderSearchResult = await _orderModule.SearchAsync(new CustomerOrderSearchCriteria() { CustomerId = user.Id, Take = 0, Skip = 0, }); user.IsFirstTimeBuyer = orderSearchResult.TotalCount == 0; options.AddExpirationToken(new PollingApiUserChangeToken(_platformSecurityApi, _options.ChangesPollingInterval)); options.AddExpirationToken(SecurityCacheRegion.CreateChangeToken(userDto.Id)); return(user); } return(null); }
/// <summary>从文件中获取缓存,若文件变更,自动刷新缓存(未测试)</summary> public static string GetFileCache(string fileName) { if (_memory.TryGetValue(fileName, out string txt)) { var fileInfo = new FileInfo(fileName); txt = File.ReadAllText(fileName); var cacheEntityOps = new MemoryCacheEntryOptions(); cacheEntityOps.AddExpirationToken(new PollingFileChangeToken(fileInfo)); // 监控文件变化 cacheEntityOps.RegisterPostEvictionCallback((key, value, reason, state) => { Console.WriteLine($"文件 {key} 改动了"); }); // 缓存失效时处理 _memory.Set(fileInfo.Name, txt, cacheEntityOps); } return(txt); }
public static void SetCache(string CacheKey, object objObject, CacheDependency depend) { if (objObject == null) { _memoryCache.Remove(CacheKey); } else { MemoryCacheEntryOptions cacheEntityOps = new MemoryCacheEntryOptions(); cacheEntityOps.AddExpirationToken(depend); _memoryCache.Set(CacheKey, objObject, cacheEntityOps); } }
private MemoryCacheEntryOptions GetOptions(TimeSpan?expires) { var options = new MemoryCacheEntryOptions(); options.SetPriority(CacheItemPriority.Normal); options.AddExpirationToken(new CancellationChangeToken(_resetCacheToken.Token)); if (expires != null) { options.SetAbsoluteExpiration(expires.Value); } return(options); }
private MemoryCacheEntryOptions CacheOptions(int size, double expireInSeconds, bool addExpitationToken = false) { var cacheOptions = new MemoryCacheEntryOptions { Size = size, AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(expireInSeconds) }; if (addExpitationToken) { cacheOptions.AddExpirationToken(new CancellationChangeToken(TipChangeCancellationTokenSource.Token)); } return(cacheOptions); }
private MemoryCacheEntryOptions GetMemoryCacheEntryOptions(string relativePath) { var options = new MemoryCacheEntryOptions(); options.AddExpirationToken(_fileProvider.Watch(relativePath)); var viewImportsPaths = ViewHierarchyUtility.GetViewImportsLocations(relativePath); foreach (var location in viewImportsPaths) { options.AddExpirationToken(_fileProvider.Watch(location)); } return options; }
private CompilerCacheResult CreateCacheEntry( string normalizedPath, Func<RelativeFileInfo, CompilationResult> compile) { CompilerCacheResult cacheResult; var fileInfo = _fileProvider.GetFileInfo(normalizedPath); MemoryCacheEntryOptions cacheEntryOptions; CompilerCacheResult cacheResultToCache; if (!fileInfo.Exists) { cacheResultToCache = CompilerCacheResult.FileNotFound; cacheResult = CompilerCacheResult.FileNotFound; cacheEntryOptions = new MemoryCacheEntryOptions(); cacheEntryOptions.AddExpirationToken(_fileProvider.Watch(normalizedPath)); } else { var relativeFileInfo = new RelativeFileInfo(fileInfo, normalizedPath); var compilationResult = compile(relativeFileInfo).EnsureSuccessful(); cacheEntryOptions = GetMemoryCacheEntryOptions(normalizedPath); // By default the CompilationResult returned by IRoslynCompiler is an instance of // UncachedCompilationResult. This type has the generated code as a string property and do not want // to cache it. We'll instead cache the unwrapped result. cacheResultToCache = new CompilerCacheResult( CompilationResult.Successful(compilationResult.CompiledType)); cacheResult = new CompilerCacheResult(compilationResult); } _cache.Set(normalizedPath, cacheResultToCache, cacheEntryOptions); return cacheResult; }
private static IMemoryCache MakeCache(object result = null) { var cache = new Mock<IMemoryCache>(); cache.CallBase = true; cache.Setup(c => c.TryGetValue(It.IsAny<string>(), out result)) .Returns(result != null); var cacheEntryOptions = new MemoryCacheEntryOptions(); cacheEntryOptions.AddExpirationToken(Mock.Of<IChangeToken>()); cache .Setup( c => c.Set( /*key*/ It.IsAny<string>(), /*value*/ It.IsAny<object>(), /*options*/ cacheEntryOptions)) .Returns(result); return cache.Object; }