public void AbsoluteExpirationExpiresInBackground() { var clock = new TestClock(); var cache = CreateCache(clock); var key = "myKey"; var value = new object(); var callbackInvoked = new ManualResetEvent(false); var options = new MemoryCacheEntryOptions() .SetAbsoluteExpiration(clock.UtcNow + TimeSpan.FromMinutes(1)) .RegisterPostEvictionCallback((subkey, subValue, reason, state) => { // TODO: Verify params var localCallbackInvoked = (ManualResetEvent)state; localCallbackInvoked.Set(); }, callbackInvoked); var result = cache.Set(key, value, options); Assert.Same(value, result); var found = cache.TryGetValue(key, out result); Assert.True(found); Assert.Same(value, result); clock.Add(TimeSpan.FromMinutes(2)); var ignored = cache.Get("otherKey"); // Background expiration checks are triggered by misc cache activity. Assert.True(callbackInvoked.WaitOne(100), "Callback"); found = cache.TryGetValue(key, out result); Assert.False(found); Assert.Null(result); }
public static void Main(string[] args) { // Runs several concurrent threads that access an item that periodically expires and is re-created. MemoryCache cache = new MemoryCache(new MemoryCacheOptions()); string key = "MyKey"; var options = new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMilliseconds(50)); var tasks = new List<Task>(); for (int threads = 0; threads < 100; threads++) { var task = Task.Run(() => { for (int i = 0; i < 110000; i++) { object value; if(!cache.TryGetValue(key, out value)) { // Fake expensive object creation. for (int j = 0; j < 1000000; j++) { } cache.Set(key, new object(), options); } } }); tasks.Add(task); } Console.WriteLine("Running"); Task.WaitAll(tasks.ToArray()); Console.WriteLine("Done"); }
public void RemoveAndReAddFromCallbackWorks() { var cache = CreateCache(); var value = new object(); var obj2 = new object(); string key = "myKey"; var callbackInvoked = new ManualResetEvent(false); var options = new MemoryCacheEntryOptions(); options.PostEvictionCallbacks.Add(new PostEvictionCallbackRegistration() { EvictionCallback = (subkey, subValue, reason, state) => { Assert.Equal(key, subkey); Assert.Same(subValue, value); Assert.Equal(EvictionReason.Removed, reason); var localCallbackInvoked = (ManualResetEvent)state; cache.Set(key, obj2); localCallbackInvoked.Set(); }, State = callbackInvoked }); var result = cache.Set(key, value, options); Assert.Same(value, result); cache.Remove(key); Assert.True(callbackInvoked.WaitOne(100), "Callback"); result = cache.Get(key); Assert.Same(obj2, result); }
/// <inheritdoc /> public ChunkTree GetOrAdd( string pagePath, Func<IFileInfo, ChunkTree> getChunkTree) { if (pagePath == null) { throw new ArgumentNullException(nameof(pagePath)); } if (getChunkTree == null) { throw new ArgumentNullException(nameof(getChunkTree)); } ChunkTree chunkTree; if (!_chunkTreeCache.TryGetValue(pagePath, out chunkTree)) { // GetOrAdd is invoked for each _ViewImport that might potentially exist in the path. // We can avoid performing file system lookups for files that do not exist by caching // negative results and adding a Watch for that file. var options = new MemoryCacheEntryOptions() .AddExpirationToken(_fileProvider.Watch(pagePath)) .SetSlidingExpiration(SlidingExpirationDuration); var file = _fileProvider.GetFileInfo(pagePath); chunkTree = file.Exists ? getChunkTree(file) : null; _chunkTreeCache.Set(pagePath, chunkTree, options); } return chunkTree; }
public void Set([NotNull] string key, byte[] value, DistributedCacheEntryOptions options) { var memoryCacheEntryOptions = new MemoryCacheEntryOptions(); memoryCacheEntryOptions.AbsoluteExpiration = options.AbsoluteExpiration; memoryCacheEntryOptions.AbsoluteExpirationRelativeToNow = options.AbsoluteExpirationRelativeToNow; memoryCacheEntryOptions.SlidingExpiration = options.SlidingExpiration; _memCache.Set(key, value, memoryCacheEntryOptions); }
internal CacheEntry( string key, object value, DateTimeOffset utcNow, DateTimeOffset? absoluteExpiration, MemoryCacheEntryOptions options, Action<CacheEntry> notifyCacheOfExpiration) { Key = key; Value = value; LastAccessed = utcNow; Options = options; _notifyCacheOfExpiration = notifyCacheOfExpiration; _absoluteExpiration = absoluteExpiration; PostEvictionCallbacks = options.PostEvictionCallbacks; }
public void Main() { _cacheEntryOptions = GetCacheEntryOptions(); IMemoryCache cache = new MemoryCache(new MemoryCacheOptions()); SetKey(cache, "0"); PriodicallyReadKey(cache, TimeSpan.FromSeconds(1)); PeriodciallyRemoveKey(cache, TimeSpan.FromSeconds(11)); PeriodciallySetKey(cache, TimeSpan.FromSeconds(13)); Console.ReadLine(); Console.WriteLine("Shutting down"); }
public LocalCacheService() { BucketOptions = new MemoryCacheEntryOptions { Priority = CacheItemPriority.High, PostEvictionCallbacks = { new PostEvictionCallbackRegistration {EvictionCallback = PostEvictionCallback, State = this} }, }; TailOptions = new MemoryCacheEntryOptions { Priority = CacheItemPriority.Low, PostEvictionCallbacks = { new PostEvictionCallbackRegistration {EvictionCallback = PostEvictionCallback, State = this} } }; }
protected object Get(ICacheKey key) { try { _lock.EnterUpgradeableReadLock(); object value; if(cache.TryGetValue(key.GetStringKey(), out value)) { return value; } OnMiss(key, out value); var cacheKey = BuildUniqueStringKey(key); var opts = new MemoryCacheEntryOptions(); if (_useAbsoluteExpiration) { opts.AbsoluteExpiration = AbsoluteExpiration; } else if (_useSlidingExpiration) { opts.SlidingExpiration = SlidingExpirationSpan; } cache.Set(key.GetStringKey(), value, opts); return value; } finally { if(_lock.IsUpgradeableReadLockHeld) { _lock.ExitUpgradeableReadLock(); } } }
/// <inheritdoc /> public CompilerCacheResult GetOrAdd( [NotNull] string relativePath, [NotNull] Func<RelativeFileInfo, CompilationResult> compile) { var normalizedPath = NormalizePath(relativePath); CompilerCacheResult cacheResult; if (!_cache.TryGetValue(normalizedPath, out cacheResult)) { var fileInfo = _fileProvider.GetFileInfo(relativePath); MemoryCacheEntryOptions cacheEntryOptions; CompilerCacheResult cacheResultToCache; if (!fileInfo.Exists) { cacheResultToCache = CompilerCacheResult.FileNotFound; cacheResult = CompilerCacheResult.FileNotFound; cacheEntryOptions = new MemoryCacheEntryOptions(); cacheEntryOptions.AddExpirationTrigger(_fileProvider.Watch(relativePath)); } else { var relativeFileInfo = new RelativeFileInfo(fileInfo, relativePath); var compilationResult = compile(relativeFileInfo).EnsureSuccessful(); cacheEntryOptions = GetMemoryCacheEntryOptions(relativePath); // 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; }
/// <inheritdoc /> public CodeTree GetOrAdd([NotNull] string pagePath, [NotNull] Func<IFileInfo, CodeTree> getCodeTree) { CodeTree codeTree; if (!_codeTreeCache.TryGetValue(pagePath, out codeTree)) { // GetOrAdd is invoked for each _GlobalImport that might potentially exist in the path. // We can avoid performing file system lookups for files that do not exist by caching // negative results and adding a Watch for that file. var options = new MemoryCacheEntryOptions() .AddExpirationTrigger(_fileProvider.Watch(pagePath)) .SetSlidingExpiration(SlidingExpirationDuration); var file = _fileProvider.GetFileInfo(pagePath); codeTree = file.Exists ? getCodeTree(file) : null; _codeTreeCache.Set(pagePath, codeTree, options); } return codeTree; }
public CacheInterceptor(InterceptDelegate next, IMemoryCache cache, IOptions <MemoryCacheEntryOptions> optionsAccessor) { _next = next; _cache = cache; _options = optionsAccessor.Value; }
public void UpdateAllMatches(List <Match> matches) { var cacheEntryoption = new MemoryCacheEntryOptions().SetAbsoluteExpiration(DateTimeOffset.Now.AddMinutes(6)); _cache.Set("matches", matches, cacheEntryoption); }
public UserManagerServicePipeline(IMemoryCache cache) { Cache = cache; MemoryCacheEntryOptions = new MemoryCacheEntryOptions(); }
public void Main() { IMemoryCache cache = new MemoryCache(new MemoryCacheOptions()); object result; string key = "Key"; object newObject = new object(); object state = new object(); // Basic CRUD operations: // Create / Overwrite result = cache.Set(key, newObject); result = cache.Set(key, new object()); // Retrieve, null if not found result = cache.Get(key); // Retrieve bool found = cache.TryGetValue(key, out result); // Delete cache.Remove(key); // Cache entry configuration: // Stays in the cache as long as possible result = cache.Set( key, new object(), new MemoryCacheEntryOptions().SetPriority(CacheItemPriority.NeverRemove)); // Automatically remove if not accessed in the given time result = cache.Set( key, new object(), new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(5))); // Automatically remove at a certain time result = cache.Set( key, new object(), new MemoryCacheEntryOptions().SetAbsoluteExpiration(DateTimeOffset.UtcNow.AddDays(2))); // Automatically remove at a certain time, which is relative to UTC now result = cache.Set( key, new object(), new MemoryCacheEntryOptions().SetAbsoluteExpiration(relative: TimeSpan.FromMinutes(10))); // Automatically remove if not accessed in the given time // Automatically remove at a certain time (if it lives that long) result = cache.Set( key, new object(), new MemoryCacheEntryOptions() .SetSlidingExpiration(TimeSpan.FromMinutes(5)) .SetAbsoluteExpiration(DateTimeOffset.UtcNow.AddDays(2))); // Callback when evicted var options = new MemoryCacheEntryOptions() .RegisterPostEvictionCallback( (echoKey, value, reason, substate) => { Console.WriteLine(echoKey + ": '" + value + "' was evicted due to " + reason); }); result = cache.Set(key, new object(), options); // Remove on token expiration var cts = new CancellationTokenSource(); options = new MemoryCacheEntryOptions() .AddExpirationToken(new CancellationChangeToken(cts.Token)) .RegisterPostEvictionCallback( (echoKey, value, reason, substate) => { Console.WriteLine(echoKey + ": '" + value + "' was evicted due to " + reason); }); result = cache.Set(key, new object(), options); // Fire the token to see the registered callback being invoked cts.Cancel(); // Expire an entry if the dependent entry expires using (var link = cache.CreateLinkingScope()) { cts = new CancellationTokenSource(); cache.Set("key1", "value1", new MemoryCacheEntryOptions() .AddExpirationToken(new CancellationChangeToken(cts.Token))); // expire this entry if the entry with key "key1" expires. cache.Set("key2", "value2", new MemoryCacheEntryOptions() .AddEntryLink(link) .RegisterPostEvictionCallback( (echoKey, value, reason, substate) => { Console.WriteLine(echoKey + ": '" + value + "' was evicted due to " + reason); })); } // Fire the token to see the registered callback being invoked cts.Cancel(); }
public void SaveDataToCache(int zipCode, string results) { var cacheEntryOptions = new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(_cacheSettings.CacheExpirationSeconds)); _cache.Set(zipCode, results, cacheEntryOptions); }
/// <summary> /// 使用自定义的 options 存进缓存 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <param name="value"></param> /// <param name="options"></param> /// <returns></returns> public static T Set <T>(object key, T value, MemoryCacheEntryOptions options) => MemoryCache.Set(key, value, options);
internal static void AddIdentityToCache(Guid userId, ErpIdentity identity) { var options = new MemoryCacheEntryOptions(); options.SetAbsoluteExpiration(TimeSpan.FromMinutes(5)); cache.Set( userId.ToString(), identity, options); // from bet4 to beta5 changed //context => //{ // context.SetAbsoluteExpiration(TimeSpan.FromMinutes(5)); // return identity; //}); }
public JArray GetSoftwares(string name = "", string ver = "", string man = "_unknown", string customerid = "") { JArray jResult = new JArray(); //Try to get value from Memory if (_cache.TryGetValue("mnv-" + man + name + ver, out jResult)) { UpdateURLs(ref jResult); return(jResult); } string sRepository = Settings["repository"]; string lookupPath = Path.Combine(sRepository, "customers", customerid, Base.clean(man.ToLower()), Base.clean(name.ToLower()), Base.clean(ver.ToLower())); if (Directory.Exists(lookupPath)) { foreach (string sFile in Directory.GetFiles(lookupPath, "*.json")) { string sJson = File.ReadAllText(sFile); try { jResult = JArray.Parse(sJson); //fix PreRequisite issue on client when parsing json with null value prerequisite foreach (JObject jObj in jResult) { JToken jPreReq; if (jObj.TryGetValue("PreRequisites", out jPreReq)) { if (string.IsNullOrEmpty(jPreReq.ToString())) { jObj["PreRequisites"] = new JArray(); } } } var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(SlidingExpiration)); //cache hash for x Seconds _cache.Set("mnv-" + man + name + ver, jResult, cacheEntryOptions); UpdateURLs(ref jResult); return(jResult); } catch { } try { jResult = new JArray(); JObject oObj = JObject.Parse(sJson); //fix PreRequisite issue on client when parsing json with null value prerequisite JToken jPreReq; if (oObj.TryGetValue("PreRequisites", out jPreReq)) { if (string.IsNullOrEmpty(jPreReq.ToString())) { oObj["PreRequisites"] = new JArray(); } } jResult.Add(oObj); var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(SlidingExpiration)); //cache hash for x Seconds _cache.Set("mnv-" + man + name + ver, jResult, cacheEntryOptions); UpdateURLs(ref jResult); return(jResult); } catch { } } } lookupPath = Path.Combine(sRepository, Base.clean(man.ToLower()), Base.clean(name.ToLower()), Base.clean(ver.ToLower())); if (Directory.Exists(lookupPath)) { foreach (string sFile in Directory.GetFiles(lookupPath, "*.json")) { string sJson = File.ReadAllText(sFile); try { jResult = JArray.Parse(sJson); //fix PreRequisite issue on client when parsing json with null value prerequisite foreach (JObject jObj in jResult) { JToken jPreReq; if (jObj.TryGetValue("PreRequisites", out jPreReq)) { if (string.IsNullOrEmpty(jPreReq.ToString())) { jObj["PreRequisites"] = new JArray(); } } } var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(SlidingExpiration)); //cache hash for x Seconds _cache.Set("mnv-" + man + name + ver, jResult, cacheEntryOptions); UpdateURLs(ref jResult); return(jResult); } catch { } try { jResult = new JArray(); JObject oObj = JObject.Parse(sJson); //fix PreRequisite issue on client when parsing json with null value prerequisite JToken jPreReq; if (oObj.TryGetValue("PreRequisites", out jPreReq)) { if (string.IsNullOrEmpty(jPreReq.ToString())) { oObj["PreRequisites"] = new JArray(); } } jResult.Add(oObj); var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(SlidingExpiration)); //cache hash for x Seconds _cache.Set("mnv-" + man + name + ver, jResult, cacheEntryOptions); UpdateURLs(ref jResult); return(jResult); } catch { } } } return(new JArray()); }
public void Set(string key, byte[] value, DistributedCacheEntryOptions options) { if (key == null) { throw new ArgumentNullException(nameof(key)); } var memoryCacheEntryOptions = new MemoryCacheEntryOptions(); memoryCacheEntryOptions.AbsoluteExpiration = options.AbsoluteExpiration; memoryCacheEntryOptions.AbsoluteExpirationRelativeToNow = options.AbsoluteExpirationRelativeToNow; memoryCacheEntryOptions.SlidingExpiration = options.SlidingExpiration; _memCache.Set(key, value, memoryCacheEntryOptions); }
public object Set(object key, object value, MemoryCacheEntryOptions cacheEntryOptions) { if (key == null) { throw new ArgumentNullException(nameof(key)); } CheckDisposed(); CacheEntry priorEntry = null; var utcNow = _clock.UtcNow; DateTimeOffset? absoluteExpiration = null; if (cacheEntryOptions.AbsoluteExpirationRelativeToNow.HasValue) { absoluteExpiration = utcNow + cacheEntryOptions.AbsoluteExpirationRelativeToNow; } else if (cacheEntryOptions.AbsoluteExpiration.HasValue) { if (cacheEntryOptions.AbsoluteExpiration <= utcNow) { throw new ArgumentOutOfRangeException( nameof(MemoryCacheEntryOptions.AbsoluteExpiration), cacheEntryOptions.AbsoluteExpiration.Value, "The absolute expiration value must be in the future."); } absoluteExpiration = cacheEntryOptions.AbsoluteExpiration; } var entry = new CacheEntry( key, value, utcNow, absoluteExpiration, cacheEntryOptions, _entryExpirationNotification); var link = EntryLinkHelpers.ContextLink; if (link != null) { // Copy expiration tokens and AbsoluteExpiration to the link. // We do this regardless of it gets cached because the tokens are associated with the value we'll return. if (entry.Options.ExpirationTokens != null) { link.AddExpirationTokens(entry.Options.ExpirationTokens); } if (absoluteExpiration.HasValue) { link.SetAbsoluteExpiration(absoluteExpiration.Value); } } bool added = false; _entryLock.EnterWriteLock(); try { if (_entries.TryGetValue(key, out priorEntry)) { _entries.Remove(key); priorEntry.SetExpired(EvictionReason.Replaced); } if (!entry.CheckExpired(utcNow)) { _entries[key] = entry; entry.AttachTokens(); added = true; } } finally { _entryLock.ExitWriteLock(); } if (priorEntry != null) { priorEntry.InvokeEvictionCallbacks(); } if (!added) { entry.InvokeEvictionCallbacks(); } StartScanForExpiredItems(); return value; }
/// <summary> /// Adds version query parameter to the specified file path. /// </summary> /// <param name="path">The path of the file to which version should be added.</param> /// <returns>Path containing the version query string.</returns> /// <remarks> /// The version query string is appended as with the key "v". /// </remarks> public string AddFileVersionToPath(string path) { if (path == null) { throw new ArgumentNullException(nameof(path)); } var resolvedPath = path; var queryStringOrFragmentStartIndex = path.IndexOfAny(new char[] { '?', '#' }); if (queryStringOrFragmentStartIndex != -1) { resolvedPath = path.Substring(0, queryStringOrFragmentStartIndex); } Uri uri; if (Uri.TryCreate(resolvedPath, UriKind.Absolute, out uri) && !uri.IsFile) { // Don't append version if the path is absolute. return path; } var fileInfo = _fileProvider.GetFileInfo(resolvedPath); if (!fileInfo.Exists) { if (_requestPathBase.HasValue && resolvedPath.StartsWith(_requestPathBase.Value, StringComparison.OrdinalIgnoreCase)) { resolvedPath = resolvedPath.Substring(_requestPathBase.Value.Length); fileInfo = _fileProvider.GetFileInfo(resolvedPath); } if (!fileInfo.Exists) { // if the file is not in the current server. return path; } } string value; if (!_cache.TryGetValue(path, out value)) { value = QueryHelpers.AddQueryString(path, VersionKey, GetHashForFile(fileInfo)); var cacheEntryOptions = new MemoryCacheEntryOptions().AddExpirationToken(_fileProvider.Watch(resolvedPath)); _cache.Set(path, value, cacheEntryOptions); } return value; }
public void SetOverwritesAndInvokesCallbacks() { var cache = CreateCache(); var value1 = new object(); string key = "myKey"; var callback1Invoked = new ManualResetEvent(false); var callback2Invoked = new ManualResetEvent(false); var options1 = new MemoryCacheEntryOptions(); options1.PostEvictionCallbacks.Add(new PostEvictionCallbackRegistration() { EvictionCallback = (subkey, subValue, reason, state) => { Assert.Equal(key, subkey); Assert.Same(subValue, value1); Assert.Equal(EvictionReason.Replaced, reason); var localCallbackInvoked = (ManualResetEvent)state; localCallbackInvoked.Set(); }, State = callback1Invoked }); var result = cache.Set(key, value1, options1); Assert.Same(value1, result); var value2 = new object(); var options2 = new MemoryCacheEntryOptions(); options2.PostEvictionCallbacks.Add(new PostEvictionCallbackRegistration() { EvictionCallback = (subkey, subValue, reason, state) => { // Shouldn't be invoked. var localCallbackInvoked = (ManualResetEvent)state; localCallbackInvoked.Set(); }, State = callback2Invoked }); result = cache.Set(key, value2, options2); Assert.Same(value2, result); Assert.True(callback1Invoked.WaitOne(100), "Callback1"); Assert.False(callback2Invoked.WaitOne(0), "Callback2"); result = cache.Get(key); Assert.Same(value2, result); Assert.False(callback2Invoked.WaitOne(0), "Callback2"); }
internal static void AddIdentityToCache(Guid userId, ErpIdentity identity) { var options = new MemoryCacheEntryOptions(); options.SetAbsoluteExpiration(TimeSpan.FromMinutes(5)); cache.Set(userId.ToString(), identity, options); }
public void Set(string key, object item, MemoryCacheEntryOptions policy) { }
public async Task <LocalRedirectResult> Callback([FromQuery] string code, [FromQuery] string state) { string _access_token; string _token_type; string _scope; int _expires_in; string _refresh_token; var SpotifyServicesConfiguration = _configuration.GetSection("SpotifyServices") .Get <SpotifyServicesConfigurations>(); var redirect_uri = SpotifyServicesConfiguration.RedirectUri; var client_id = SpotifyServicesConfiguration.ClientId; var client_secret = SpotifyServicesConfiguration.ClientSecret; var request = new HttpRequestMessage(HttpMethod.Post, SpotifyServicesConfiguration.AuthorizeAPIBaseURI + "/api/token"); var client = _clientFactory.CreateClient(); var RequestBody = new Dictionary <string, string>(); RequestBody.Add("grant_type", "authorization_code"); RequestBody.Add("code", code); RequestBody.Add("redirect_uri", redirect_uri); request.Content = new FormUrlEncodedContent(RequestBody); var Credentials = client_id + ":" + client_secret; byte[] data = System.Text.ASCIIEncoding.ASCII.GetBytes(Credentials); var base64EncodedCredentials = System.Convert.ToBase64String(data); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", base64EncodedCredentials); var response = await client.SendAsync(request); var content = await response.Content.ReadAsStringAsync(); var _spotifyservicesapitoken = JsonSerializer.Deserialize <SpotifyServicesAPIToken>(content); if (!_cache.TryGetValue(SpotifyServicesAPITokenCache.access_token, out _access_token)) { _access_token = _spotifyservicesapitoken.access_token; var cacheEntryOptions = new MemoryCacheEntryOptions(); _cache.Set(SpotifyServicesAPITokenCache.access_token, _access_token, cacheEntryOptions); } if (!_cache.TryGetValue(SpotifyServicesAPITokenCache.token_type, out _token_type)) { _token_type = _spotifyservicesapitoken.token_type; var cacheEntryOptions = new MemoryCacheEntryOptions(); _cache.Set(SpotifyServicesAPITokenCache.token_type, _token_type, cacheEntryOptions); } if (!_cache.TryGetValue(SpotifyServicesAPITokenCache.scope, out _scope)) { _scope = _spotifyservicesapitoken.scope; var cacheEntryOptions = new MemoryCacheEntryOptions(); _cache.Set(SpotifyServicesAPITokenCache.scope, _scope, cacheEntryOptions); } if (!_cache.TryGetValue(SpotifyServicesAPITokenCache.expires_in, out _expires_in)) { _expires_in = _spotifyservicesapitoken.expires_in; var cacheEntryOptions = new MemoryCacheEntryOptions(); _cache.Set(SpotifyServicesAPITokenCache.expires_in, _expires_in, cacheEntryOptions); } if (!_cache.TryGetValue(SpotifyServicesAPITokenCache.refresh_token, out _refresh_token)) { _refresh_token = _spotifyservicesapitoken.refresh_token; var cacheEntryOptions = new MemoryCacheEntryOptions(); _cache.Set(SpotifyServicesAPITokenCache.refresh_token, _refresh_token, cacheEntryOptions); } return(LocalRedirect("/MusicPage")); }
public JArray GetSoftwares(string shortname, string customerid = "") { JArray jResult = new JArray(); //Try to get value from Memory if (_cache.TryGetValue("sn-" + shortname, out jResult)) { UpdateURLs(ref jResult); return(jResult); } string sRepository = Settings["repository"]; if (!File.Exists(Path.Combine(sRepository, Base.clean(shortname.ToLower()) + ".json"))) { return(new JArray()); } string sJson = File.ReadAllText(Path.Combine(sRepository, Base.clean(shortname.ToLower()) + ".json")); try { if (sJson.TrimStart().StartsWith("[")) { jResult = JArray.Parse(sJson); } else { JObject jObj = JObject.Parse(sJson); jResult = new JArray(); jResult.Add(jObj); } //fix PreRequisite issue on client when parsing json with null value prerequisite foreach (JObject jObj in jResult) { JToken jPreReq; if (jObj.TryGetValue("PreRequisites", out jPreReq)) { if (string.IsNullOrEmpty(jPreReq.ToString())) { jObj["PreRequisites"] = new JArray(); } } } var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(SlidingExpiration)); //cache hash for x Seconds _cache.Set("sn-" + shortname, jResult, cacheEntryOptions); UpdateURLs(ref jResult); return(jResult); } catch { } try { jResult = new JArray(); JObject oObj = JObject.Parse(sJson); //fix PreRequisite issue on client when parsing json with null value prerequisite JToken jPreReq; if (oObj.TryGetValue("PreRequisites", out jPreReq)) { if (string.IsNullOrEmpty(jPreReq.ToString())) { oObj["PreRequisites"] = new JArray(); } } jResult.Add(oObj); var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(SlidingExpiration)); //cache hash for x Seconds _cache.Set("sn-" + shortname, jResult, cacheEntryOptions); UpdateURLs(ref jResult); return(jResult); } catch { } return(new JArray()); }
public static Func <T1, T2, T3, TResult> Create <T1, T2, T3, TResult>(Func <T1, T2, T3, TResult> func, MemoryCacheEntryOptions options) { return(Create(func, DefaultCache ?? throw new InvalidOperationException("Memoization.DefaultCache is null"), options)); }
public async Task ProcessAsync_FlowsEntryLinkThatAllowsAddingTriggersToAddedEntry() { // Arrange var id = "some-id"; var expectedContent = new DefaultTagHelperContent(); expectedContent.SetContent("some-content"); var tokenSource = new CancellationTokenSource(); var cache = new MemoryCache(new MemoryCacheOptions()); var cacheEntryOptions = new MemoryCacheEntryOptions() .AddExpirationTrigger(new CancellationTokenTrigger(tokenSource.Token)); var tagHelperContext = new TagHelperContext( allAttributes: new TagHelperAttributeList(), items: new Dictionary<object, object>(), uniqueId: id, getChildContentAsync: () => { TagHelperContent tagHelperContent; if(!cache.TryGetValue("key1", out tagHelperContent)) { tagHelperContent = expectedContent; cache.Set("key1", tagHelperContent, cacheEntryOptions); } return Task.FromResult(tagHelperContent); }); var tagHelperOutput = new TagHelperOutput("cache", new TagHelperAttributeList { { "attr", "value" } }); tagHelperOutput.PreContent.SetContent("<cache>"); tagHelperOutput.PostContent.SetContent("</cache>"); var cacheTagHelper = new CacheTagHelper(cache) { ViewContext = GetViewContext(), }; var key = cacheTagHelper.GenerateKey(tagHelperContext); // Act - 1 await cacheTagHelper.ProcessAsync(tagHelperContext, tagHelperOutput); TagHelperContent cachedValue; var result = cache.TryGetValue(key, out cachedValue); // Assert - 1 Assert.Equal(expectedContent.GetContent(), tagHelperOutput.Content.GetContent()); Assert.True(result); Assert.Equal(expectedContent, cachedValue); // Act - 2 tokenSource.Cancel(); result = cache.TryGetValue(key, out cachedValue); // Assert - 2 Assert.False(result); Assert.Null(cachedValue); }
private async Task ProcessRequest(HttpContext context, string requestKey, int hitCount, MemoryCacheEntryOptions cacheEntryOptions) { hitCount++; requestStore.Set(requestKey, hitCount, cacheEntryOptions); context.Response.Headers["X-Rate-Limit"] = limit.ToString(); context.Response.Headers["X-Rate-Limit-Remaining"] = (limit - hitCount).ToString(); await next(context); }
public Task <T> GetOrAddAsync <T>(string key, Func <ICacheEntry, Task <T> > addItemFactory, MemoryCacheEntryOptions policy) { return(addItemFactory(new MockCacheEntry(key))); }
public static void SetSliding <T>(this IMemoryCache cache, Object key, T value, Int32 minutesCount) { var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(minutesCount)); cache.Set(key, value, cacheEntryOptions); }
public void Add <T>(string key, T item, MemoryCacheEntryOptions policy) { }
public async Task <CommandResult <Step> > Handle(AssignStepCommand request, CancellationToken cancellationToken) { var stopwatch = new Stopwatch(); stopwatch.Start(); List <Guid> ignoreUnassignedSteps = new List <Guid>(); if (_clusterStateService.GetSettings.AssignmentEnabled) { var assignedStepSuccessfully = false; Step unassignedStep = null; var dateChecked = DateTime.UtcNow; BotKey botkey; if (!_cache.TryGetValue(request.BotId, out botkey)) { // Set cache options. var cacheEntryOptions = new MemoryCacheEntryOptions() // Keep in cache for this time, reset time if accessed. .SetSlidingExpiration(TimeSpan.FromSeconds(10)); botkey = await _entitiesRepository.GetFirstOrDefaultAsync <BotKey>(bk => bk.Id == request.BotId); // Save data in cache. _cache.Set(request.BotId, botkey, cacheEntryOptions); } if (botkey.IsDisabled) { return(new CommandResult <Step>(new BotKeyAssignmentException("Bot " + botkey.Id + " is disabled.")) { Type = CommandResultTypes.Update, ElapsedMs = stopwatch.ElapsedMilliseconds }); } ignoreUnassignedSteps.AddRange(_clusterStateService.GetState().Locks.Where(l => l.Key.Contains("_object")).Select(ol => new Guid(ol.Key.Split(':').Last()))); do { unassignedStep = (await _entitiesRepository.GetAsync <Step>(s => s.Status == StepStatuses.Unassigned && request.StepTemplateIds.Contains(s.StepTemplateId) && !ignoreUnassignedSteps.Contains(s.Id), null, "CreatedOn:1", 1, 0)).FirstOrDefault(); if (unassignedStep != null) { var assigned = await _node.Handle(new RequestDataShard() { Type = unassignedStep.ShardType, ObjectId = unassignedStep.Id, CreateLock = true, LockTimeoutMs = 10000 }); //Apply a lock on the item if (assigned != null && assigned.IsSuccessful && assigned.AppliedLocked) { //Real values to pass to the Microservice Dictionary <string, object> realAssignedValues = new Dictionary <string, object>(); //Inputs that have been converted to reference expression Dictionary <string, object> convertedInputs = new Dictionary <string, object>(); var template = await _entitiesRepository.GetFirstOrDefaultAsync <StepTemplate>(st => st.ReferenceId == unassignedStep.StepTemplateId); try { //This should not throw a error externally, the server should loop to the next one and log a error if (unassignedStep.Status != StepStatuses.Unassigned) { throw new InvalidStepQueueException("You cannot assign step " + unassignedStep.Id + " as it is not unassigned."); } bool inputsUpdated = false; foreach (var input in unassignedStep.Inputs) { string convertedValue = ""; bool isReferenceByValue = false; var isReference = InputDataUtility.IsInputReference(input, out convertedValue, out isReferenceByValue); if (input.Value is string && ((string)input.Value).Length > 1) { if (isReference) { //Copy by reference if (isReferenceByValue) { var foundGlobalValue = await _entitiesRepository.GetFirstOrDefaultAsync <GlobalValue>(gv => gv.Name == convertedValue); if (foundGlobalValue == null) { Logger.LogWarning("No global value was found for value " + input.Value); realAssignedValues.Add(input.Key, null); convertedInputs.Add(input.Key, input.Value + ":?"); } else if (foundGlobalValue.Type != template.InputDefinitions[input.Key].Type) { Logger.LogWarning("Global value was found for value " + input.Value + " however they are different types. " + template.InputDefinitions[input.Key].Type + " vs " + foundGlobalValue.Type); realAssignedValues.Add(input.Key, null); convertedInputs.Add(input.Key, input.Value + ":?"); } else { realAssignedValues.Add(input.Key, foundGlobalValue.Value); convertedInputs.Add(input.Key, input.Value + ":" + foundGlobalValue.Journal.GetCurrentChainId()); } } //copy by value else { var foundGlobalValue = await _entitiesRepository.GetFirstOrDefaultAsync <GlobalValue>(gv => gv.Name == convertedValue); if (foundGlobalValue == null) { Logger.LogWarning("No global value was found for value " + input.Value); realAssignedValues.Add(input.Key, null); convertedInputs.Add(input.Key, null); } else if (foundGlobalValue.Type != template.InputDefinitions[input.Key].Type) { Logger.LogWarning("Global value was found for value " + input.Value + " however they are different types. " + template.InputDefinitions[input.Key].Type + " vs " + foundGlobalValue.Type); realAssignedValues.Add(input.Key, null); convertedInputs.Add(input.Key, null); } else { realAssignedValues.Add(input.Key, foundGlobalValue.Value); convertedInputs.Add(input.Key, foundGlobalValue.Value); } } inputsUpdated = true; } else if (input.Value is string && ((string)input.Value).Length > 1 && ((string)input.Value).First() == '\\') { var escapedCommand = ((string)input.Value); //The $ is escaped realAssignedValues.Add(input.Key, ((string)input.Value).Substring(1, escapedCommand.Length - 1)); convertedInputs.Add(input.Key, input.Value); inputsUpdated = true; } else { realAssignedValues.Add(input.Key, input.Value); convertedInputs.Add(input.Key, input.Value); } } else { realAssignedValues.Add(input.Key, input.Value); convertedInputs.Add(input.Key, input.Value); } } //If a update was detected then add it to the journal updates if (inputsUpdated) { unassignedStep.UpdateJournal(new Domain.Entities.JournalEntries.JournalEntry() { CreatedBy = SystemUsers.QUEUE_MANAGER, CreatedOn = DateTime.UtcNow, Updates = new List <Update>() { new Update() { Type = UpdateType.Override, FieldName = "status", Value = StepStatuses.Assigned }, new Update() { FieldName = "inputs", Type = UpdateType.Override, Value = convertedInputs }, new Update() { FieldName = "assignedto", Type = UpdateType.Override, Value = request.BotId } } }); } else { unassignedStep.UpdateJournal(new Domain.Entities.JournalEntries.JournalEntry() { CreatedBy = SystemUsers.QUEUE_MANAGER, CreatedOn = DateTime.UtcNow, Updates = new List <Update>() { new Update() { Type = UpdateType.Override, FieldName = "status", Value = StepStatuses.Assigned } } }); } await _node.Handle(new AddShardWriteOperation() { Data = unassignedStep, WaitForSafeWrite = true, Operation = ConsensusCore.Domain.Enums.ShardOperationOptions.Update, RemoveLock = true, LockId = assigned.LockId.Value }); //await _entitiesRepository.UpdateStep(unassignedStep); if (inputsUpdated) { //Update the record with real values, this is not commited to DB unassignedStep.UpdateJournal(new Domain.Entities.JournalEntries.JournalEntry() { CreatedBy = SystemUsers.QUEUE_MANAGER, CreatedOn = DateTime.UtcNow, Updates = new List <Update>() { new Update() { FieldName = "inputs", Type = UpdateType.Override, Value = realAssignedValues } } }); } } catch (Exception e) { Console.WriteLine(e.Message); //throw e; } assignedStepSuccessfully = true; } else { ignoreUnassignedSteps.Add(unassignedStep.Id); assignedStepSuccessfully = false; } } //There were no unassigned steps to assign else { assignedStepSuccessfully = true; } }while (!assignedStepSuccessfully); if (unassignedStep != null) { var template = await _entitiesRepository.GetFirstOrDefaultAsync <StepTemplate>(st => st.ReferenceId == unassignedStep.StepTemplateId); //Decrypt the step unassignedStep.Inputs = DynamicDataUtility.DecryptDynamicData(template.InputDefinitions, unassignedStep.Inputs, EncryptionProtocol.AES256, ClusterStateService.GetEncryptionKey()); unassignedStep.RemoveDelimiters(); //Encrypt the step unassignedStep.Inputs = DynamicDataUtility.EncryptDynamicData(template.InputDefinitions, unassignedStep.Inputs, EncryptionProtocol.RSA, botkey.PublicEncryptionKey, true); } stopwatch.Stop(); return(new CommandResult <Step>() { ObjectRefId = unassignedStep != null?unassignedStep.Id.ToString() : "", ElapsedMs = stopwatch.ElapsedMilliseconds, Type = CommandResultTypes.Update, Result = unassignedStep != null ? unassignedStep : null }); } else { return(new CommandResult <Step>() { ObjectRefId = "", ElapsedMs = stopwatch.ElapsedMilliseconds, Type = CommandResultTypes.None }); } }
public void SetCache <T>(string key, T value, MemoryCacheEntryOptions options) where T : class { _cache.Set(key, value, options); }
public CacheManager(IMemoryCache memoryCache) { _memoryCache = memoryCache; memoryCacheEntryOptions = new MemoryCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(20) }; }
public Task HandleScheduleAsync() { var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(20)); DateTime?lastUpdatedTimeCache; Dictionary <int, ProductViewModel> productsCache; // We keep two cahces: Products and LastUpdatedTime. // If Products Cache is empty; we fill it with all data. And setup LastUpdatedTime Cache with the highest LastUpdatedDate value among products. // If Products Cache is already full; we get products from database which has higher LastUpdatedTime from our cached update time (holding in LastUpdatedTime cache) // Then update Products Cache with the returned products from database. if (!_cache.TryGetValue("Products", out productsCache)) { productsCache = _context.Products .Select(p => new ProductViewModel { Id = p.Id, Name = p.Name, LastUpdatedTime = p.LastUpdatedTime }).ToDictionary(p => p.Id, p => p); _cache.Set("Products", productsCache, cacheEntryOptions); //set LastUpdatedTimeCache lastUpdatedTimeCache = productsCache.Where(p => p.Value.LastUpdatedTime != null)?.Max(p => p.Value.LastUpdatedTime); _cache.Set("LastUpdatedTime", lastUpdatedTimeCache ?? DateTime.Now, cacheEntryOptions); } else { lastUpdatedTimeCache = (DateTime)_cache.Get("LastUpdatedTime"); //return updated products after the last cache update: add null values too List <ProductViewModel> lastUpdatedProducts = _context.Products.Where(p => p.LastUpdatedTime > lastUpdatedTimeCache || p.LastUpdatedTime == null) .Select(p => new ProductViewModel { Id = p.Id, Name = p.Name, LastUpdatedTime = p.LastUpdatedTime }).ToList(); foreach (ProductViewModel updatedProduct in lastUpdatedProducts) { if (productsCache.ContainsKey(updatedProduct.Id)) { productsCache[updatedProduct.Id] = updatedProduct; } else { productsCache.Add(updatedProduct.Id, updatedProduct); } } _cache.Set("Products", productsCache, cacheEntryOptions); //set LastUpdatedTimeCache lastUpdatedTimeCache = productsCache.Where(p => p.Value.LastUpdatedTime != null)?.Max(p => p.Value.LastUpdatedTime); _cache.Set("LastUpdatedTime", lastUpdatedTimeCache ?? DateTime.Now, cacheEntryOptions); } return(Task.CompletedTask); }
public void UpdateMatchByKey(string key, Match match) { var cacheEntryoption = new MemoryCacheEntryOptions().SetAbsoluteExpiration(DateTimeOffset.Now.AddMinutes(6)); _cache.Set(key, match, cacheEntryoption); }
protected void StoreInCache(DnsQuestion dnsQuestionInput, List <DnsRecordBase> data, MemoryCacheEntryOptions cacheEntryOptions) { CacheManager.StoreInCache(dnsQuestionInput, data, cacheEntryOptions); }
public object GetOrCreate <T>(string key, MemoryCacheEntryOptions policy, Func <ICacheEntry, T> func) { return(func(null)); }
/// <summary> /// Return the result of the <paramref name="query" /> from the cache. If the query is not cached /// yet, the query is materialized and cached before being returned. /// </summary> /// <typeparam name="T">The generic type of the query.</typeparam> /// <param name="query">The query to cache in the QueryCacheManager.</param> /// <param name="options">The cache entry options to use to cache the query.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="tags"> /// A variable-length parameters list containing tags to expire cached /// entries. /// </param> /// <returns>The result of the query.</returns> public static Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, MemoryCacheEntryOptions options, params string[] tags) { return(query.FromCacheAsync(options, default(CancellationToken), tags)); }
/// <summary> /// Get or add item to cache /// </summary> /// <typeparam name="T"></typeparam> /// <param name="cache"></param> /// <param name="key"></param> /// <param name="addItemFactory"></param> /// <param name="policy"></param> /// <returns></returns> public static Task <T> GetOrAddAsync <T>(this IAppCache cache, string key, Func <Task <T> > addItemFactory, MemoryCacheEntryOptions policy) { if (cache == null) { throw new ArgumentNullException(nameof(cache)); } return(cache.GetOrAddAsync(key, entry => { entry.SetOptions(policy); return addItemFactory(); })); }
public static Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> Create <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(Func <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> func, IMemoryCache cache, MemoryCacheEntryOptions options) { return((T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16) => { var key = (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16); if (!cache.TryGetValue <TResult>(key, out var result)) { var entry = cache.CreateEntry(key); result = func(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16); entry.SetOptions(options); entry.SetValue(result); // need to manually call dispose instead of having a using // in case the factory passed in throws, in which case we // do not want to add the entry to the cache entry.Dispose(); } return result; }); }
private Task <CompiledViewDescriptor> OnCacheMiss(string normalizedPath) { ViewCompilerWorkItem item; TaskCompletionSource <CompiledViewDescriptor> taskSource; MemoryCacheEntryOptions cacheEntryOptions; // Safe races cannot be allowed when compiling Razor pages. To ensure only one compilation request succeeds // per file, we'll lock the creation of a cache entry. Creating the cache entry should be very quick. The // actual work for compiling files happens outside the critical section. lock (_cacheLock) { // Double-checked locking to handle a possible race. if (_cache.TryGetValue(normalizedPath, out Task <CompiledViewDescriptor> result)) { return(result); } if (_precompiledViews.TryGetValue(normalizedPath, out var precompiledView)) { Log.ViewCompilerLocatedCompiledViewForPath(_logger, normalizedPath); item = CreatePrecompiledWorkItem(normalizedPath, precompiledView); } else { item = CreateRuntimeCompilationWorkItem(normalizedPath); } // At this point, we've decided what to do - but we should create the cache entry and // release the lock first. cacheEntryOptions = new MemoryCacheEntryOptions(); Debug.Assert(item.ExpirationTokens != null); for (var i = 0; i < item.ExpirationTokens.Count; i++) { cacheEntryOptions.ExpirationTokens.Add(item.ExpirationTokens[i]); } taskSource = new TaskCompletionSource <CompiledViewDescriptor>(creationOptions: TaskCreationOptions.RunContinuationsAsynchronously); if (item.SupportsCompilation) { // We'll compile in just a sec, be patient. } else { // If we can't compile, we should have already created the descriptor Debug.Assert(item.Descriptor != null); taskSource.SetResult(item.Descriptor); } _cache.Set(normalizedPath, taskSource.Task, cacheEntryOptions); } // Now the lock has been released so we can do more expensive processing. if (item.SupportsCompilation) { Debug.Assert(taskSource != null); if (item.Descriptor?.Item != null && ChecksumValidator.IsItemValid(_projectEngine.FileSystem, item.Descriptor.Item)) { // If the item has checksums to validate, we should also have a precompiled view. Debug.Assert(item.Descriptor != null); taskSource.SetResult(item.Descriptor); return(taskSource.Task); } Log.ViewCompilerInvalidatingCompiledFile(_logger, item.NormalizedPath); try { var descriptor = CompileAndEmit(normalizedPath); descriptor.ExpirationTokens = cacheEntryOptions.ExpirationTokens; taskSource.SetResult(descriptor); } catch (Exception ex) { taskSource.SetException(ex); } } return(taskSource.Task); }
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; }
public string AddFileVersionToPath(PathString requestPathBase, string path) { if (path == null) { throw new ArgumentNullException(nameof(path)); } var resolvedPath = path; var queryStringOrFragmentStartIndex = path.IndexOfAny(QueryStringAndFragmentTokens); if (queryStringOrFragmentStartIndex != -1) { resolvedPath = path.Substring(0, queryStringOrFragmentStartIndex); } if (Uri.TryCreate(resolvedPath, UriKind.Absolute, out var uri) && !uri.IsFile) { // Don't append version if the path is absolute. return(path); } // Try to get the hash from the tenant level cache. if (_cache.TryGetValue(resolvedPath, out string value)) { if (value.Length > 0) { return(QueryHelpers.AddQueryString(path, VersionKey, value)); } return(path); } // Try to get the hash from the cache shared accross tenants. if (resolvedPath.StartsWith(requestPathBase.Value, StringComparison.OrdinalIgnoreCase)) { if (_sharedCache.TryGetValue(resolvedPath.Substring(requestPathBase.Value.Length), out value)) { return(QueryHelpers.AddQueryString(path, VersionKey, value)); } } var cacheKey = resolvedPath; var cacheEntryOptions = new MemoryCacheEntryOptions(); foreach (var fileProvider in _fileProviders) { cacheEntryOptions.AddExpirationToken(fileProvider.Watch(resolvedPath)); var fileInfo = fileProvider.GetFileInfo(resolvedPath); // Perform check against requestPathBase. if (!fileInfo.Exists && requestPathBase.HasValue && resolvedPath.StartsWith(requestPathBase.Value, StringComparison.OrdinalIgnoreCase)) { resolvedPath = resolvedPath.Substring(requestPathBase.Value.Length); cacheEntryOptions.AddExpirationToken(fileProvider.Watch(resolvedPath)); fileInfo = fileProvider.GetFileInfo(resolvedPath); } // Perform check against VirtualPathBase. if (!fileInfo.Exists && fileProvider is IVirtualPathBaseProvider virtualPathBaseProvider && virtualPathBaseProvider.VirtualPathBase.HasValue && resolvedPath.StartsWith(virtualPathBaseProvider.VirtualPathBase.Value, StringComparison.OrdinalIgnoreCase)) { resolvedPath = resolvedPath.Substring(virtualPathBaseProvider.VirtualPathBase.Value.Length); cacheEntryOptions.AddExpirationToken(fileProvider.Watch(resolvedPath)); fileInfo = fileProvider.GetFileInfo(resolvedPath); } if (fileInfo.Exists) { value = GetHashForFile(fileInfo); cacheEntryOptions.SetSize(value.Length * sizeof(char)); // Cache module static files to the shared cache. if (fileProvider is IModuleStaticFileProvider) { _sharedCache.Set(resolvedPath, value, cacheEntryOptions); } else { _cache.Set(cacheKey, value, cacheEntryOptions); } return(QueryHelpers.AddQueryString(path, VersionKey, value)); } } // If the file is not in the current server, set cache so no further checks are done. cacheEntryOptions.SetSize(0); _cache.Set(cacheKey, String.Empty, cacheEntryOptions); return(path); }
public object Set(object key, object value, MemoryCacheEntryOptions options) { return(value); }
/// <summary> /// Return the result of the <paramref name="query" /> from the cache. If the query is not cached /// yet, the query is materialized and cached before being returned. /// </summary> /// <typeparam name="T">The generic type of the query.</typeparam> /// <param name="query">The query to cache in the QueryCacheManager.</param> /// <param name="options">The cache entry options to use to cache the query.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="tags"> /// A variable-length parameters list containing tags to expire cached /// entries. /// </param> /// <returns>The result of the query.</returns> public static async Task <T> FromCacheAsync <T>(this QueryDeferred <T> query, MemoryCacheEntryOptions options, CancellationToken cancellationToken = default(CancellationToken), params string[] tags) { if (!QueryCacheManager.IsEnabled) { return(await query.ExecuteAsync(cancellationToken).ConfigureAwait(false)); } var key = QueryCacheManager.GetCacheKey(query, tags); object item; if (!QueryCacheManager.Cache.TryGetValue(key, out item)) { item = await query.ExecuteAsync(cancellationToken).ConfigureAwait(false); item = QueryCacheManager.Cache.Set(key, item ?? DBNull.Value, options); QueryCacheManager.AddCacheTag(key, tags); QueryCacheManager.AddCacheTag(key, typeof(T).Name + QueryCacheManager.CacheTypeSuffix); } item = item.IfDbNullThenNull(); return((T)item); }
private MemoryCacheEntryOptions GetMemoryCacheEntryOptions(string relativePath) { var options = new MemoryCacheEntryOptions(); options.AddExpirationTrigger(_fileProvider.Watch(relativePath)); var viewImportsPaths = ViewHierarchyUtility.GetViewImportsLocations(relativePath); foreach (var location in viewImportsPaths) { options.AddExpirationTrigger(_fileProvider.Watch(location)); } return options; }
public static Func <T1, T2, TResult> Create <T1, T2, TResult>(Func <T1, T2, TResult> func, IMemoryCache cache, MemoryCacheEntryOptions options) { return((T1 t1, T2 t2) => { var key = (t1, t2); if (!cache.TryGetValue <TResult>(key, out var result)) { var entry = cache.CreateEntry(key); result = func(t1, t2); entry.SetOptions(options); entry.SetValue(result); // need to manually call dispose instead of having a using // in case the factory passed in throws, in which case we // do not want to add the entry to the cache entry.Dispose(); } return result; }); }
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; }
// Internal for unit testing internal MemoryCacheEntryOptions GetMemoryCacheEntryOptions(IEntryLink entryLink) { var options = new MemoryCacheEntryOptions(); if (ExpiresOn != null) { options.SetAbsoluteExpiration(ExpiresOn.Value); } if (ExpiresAfter != null) { options.SetAbsoluteExpiration(ExpiresAfter.Value); } if (ExpiresSliding != null) { options.SetSlidingExpiration(ExpiresSliding.Value); } if (Priority != null) { options.SetPriority(Priority.Value); } options.AddEntryLink(entryLink); return options; }
public object Set(object key, object value, MemoryCacheEntryOptions cacheEntryOptions) { throw new NotImplementedException(); }
public Task RenewAsync(string key, AuthenticationTicket ticket) { var options = new MemoryCacheEntryOptions(); var expiresUtc = ticket.Properties.ExpiresUtc; if (expiresUtc.HasValue) { options.SetAbsoluteExpiration(expiresUtc.Value); } options.SetSlidingExpiration(TimeSpan.FromHours(1)); // TODO: configurable. _cache.Set(key, ticket, options); return Task.FromResult(0); }