C# IMemoryCache.Set方法代码示例

        private void PriodicallyReadKey(IMemoryCache cache, TimeSpan interval)
        {
            Task.Run(async () =>
            {
                while (true)
                {
                    await Task.Delay(interval);

                    if (Random.Next(3) == 0) // 1/3 chance
                    {
                        // Allow values to expire due to sliding refresh.
                        Console.WriteLine("Read skipped, random choice.");
                    }
                    else
                    {
                        Console.Write("Reading...");
                        object result;
                        if(!cache.TryGetValue(Key, out result))
                        {
                            result = cache.Set(Key, "B", _cacheEntryOptions);
                        }
                        Console.WriteLine("Read: " + (result ?? "(null)"));
                    }
                }
            });
        }

        public DefaultTagCache(ITagRemovedEventHandler tagRemovedEventHandler, IMemoryCache memoryCache)
        {
            // We use the memory cache as the state holder and keep this class transient as it has
            // dependencies on non-singletons

            if(!memoryCache.TryGetValue(CacheKey, out _dictionary))
            {
                _dictionary = new ConcurrentDictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);
                memoryCache.Set(CacheKey, _dictionary);
            }
            
            _tagRemovedEventHandler = tagRemovedEventHandler;
        }

        internal CompilerCache(IEnumerable<RazorFileInfoCollection> razorFileInfoCollections,
                               IAssemblyLoadContext loadContext,
                               IFileProvider fileProvider)
        {
            _fileProvider = fileProvider;
            _cache = new MemoryCache(new MemoryCacheOptions { CompactOnMemoryPressure = false });

            var cacheEntries = new List<CompilerCacheEntry>();
            foreach (var viewCollection in razorFileInfoCollections)
            {
                var containingAssembly = viewCollection.LoadAssembly(loadContext);
                foreach (var fileInfo in viewCollection.FileInfos)
                {
                    var viewType = containingAssembly.GetType(fileInfo.FullTypeName);
                    var cacheEntry = new CompilerCacheEntry(fileInfo, viewType);

                    // There shouldn't be any duplicates and if there are any the first will win.
                    // If the result doesn't match the one on disk its going to recompile anyways.
                    var normalizedPath = NormalizePath(fileInfo.RelativePath);
                    _cache.Set(
                        normalizedPath,
                        cacheEntry,
                        GetMemoryCacheEntryOptions(fileInfo.RelativePath));

                    cacheEntries.Add(cacheEntry);
                }
            }

            // Set up _ViewImports
            foreach (var entry in cacheEntries)
            {
                var globalFileLocations = ViewHierarchyUtility.GetViewImportsLocations(entry.RelativePath);
                foreach (var location in globalFileLocations)
                {
                    var globalFileEntry = _cache.Get<CompilerCacheEntry>(location);
                    if (globalFileEntry != null)
                    {
                        // Add the composite _ViewImports entry as a dependency.
                        entry.AssociatedGlobalFileEntry = globalFileEntry;
                        break;
                    }
                }
            }
        }

        internal CompilerCache(
            IEnumerable<RazorFileInfoCollection> razorFileInfoCollections,
            IAssemblyLoadContext loadContext,
            IFileProvider fileProvider)
        {
            _fileProvider = fileProvider;
            _cache = new MemoryCache(new MemoryCacheOptions { CompactOnMemoryPressure = false });

            foreach (var viewCollection in razorFileInfoCollections)
            {
                var containingAssembly = viewCollection.LoadAssembly(loadContext);
                foreach (var fileInfo in viewCollection.FileInfos)
                {
                    var viewType = containingAssembly.GetType(fileInfo.FullTypeName);
                    var cacheEntry = new CompilerCacheResult(CompilationResult.Successful(viewType));
                    var normalizedPath = NormalizePath(fileInfo.RelativePath);
                    _cache.Set(normalizedPath, cacheEntry);
                }
            }
        }

        public async Task GetRecentActivity(
            string bracket,
            BattleDotSwag.Locale locale,
            BattleDotSwag.Region region,
            string key,
            IMemoryCache cache,
            Func<string, Task> Send)
        {
            var endpoint = new LeaderboardEndpoint(bracket, locale, key);
            var requestor = new BattleNetService();
            var leaderboard = new List<LadderEntry>();
            var request = new QueueDodge.Models.BattleNetRequest()
            {
                Bracket = bracket,
                Locale = locale.ToString(),
                RegionID = (int)region,
                RequestDate = DateTime.Now,
                RequestType = "leaderboard",
                Url = requestor.GetUri(endpoint, region).ToString(),
                Duration = 0
            };

            var addedRequest = data.BattleNetRequests.Add(request).Entity;
            data.SaveChanges();

            var json = requestor.Get(endpoint, region).Result;

            var ladder = JsonConvert.DeserializeObject<Leaderboard>(json);



            foreach(var entry in ladder.Rows)
            {
                var ladderEntry = new LadderEntry(entry, addedRequest);
                leaderboard.Add(ladderEntry);
                CompareWithCache(ladderEntry, cache, Send);
            };

            cache.Set(region + ":" + bracket, leaderboard);
        }

 private void SetKey(IMemoryCache cache, string value)
 {
     Console.WriteLine("Setting: " + value);
     cache.Set(Key, value, ConfigureEntry);
 }

        private async Task CompareWithCache(LadderEntry entry, IMemoryCache cache, Func<string, Task> Send)
        {
            var key = entry.Request.RegionID + ":" + entry.RealmID + ":" + entry.Name;

            LadderEntry cachedEntry = default(LadderEntry);

            var cached = cache.TryGetValue(key, out cachedEntry);

            cache.Set(key, entry);

            if (cached)
            {
                var change = new LadderChange(cachedEntry, entry);

                if (change.Changed())
                {
                    SaveChange(change);
                    BroadcastChange(change, Send);              
                }
            }
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IMemoryCache cache, IOptions<HawkOptions> optionsAccessor)
        {
            loggerFactory.MinimumLevel = LogLevel.Information;
            loggerFactory.AddConsole();

            var logger = loggerFactory.CreateLogger(nameof(Startup));

            var options = optionsAccessor.Options;

            Action load = GetContentLoader(options, env, cache, logger);
            load();
            cache.Set("Hawk.ReloadContent", load);

            app.UseApplicationInsightsRequestTelemetry();

            if (env.IsDevelopment())
            {
                // Only use the detailed error page in development environment.
                app.UseErrorPage();
            }
            else
            {
                app.UseErrorHandler("/Home/Error");
            }

            app.UseMiddleware<DasBlogRedirector>();

            app.UseApplicationInsightsExceptionTelemetry();

            app.UseStaticFiles(new StaticFileOptions() { ServeUnknownFileTypes = env.IsDevelopment() });
            app.UseMvcWithDefaultRoute();
        }