public SonicCache(Guid cacheId, SonicAPI.Query query) { ThrowIf.Null(query, "query"); Query = query; CacheID = cacheId; CacheFolder = ApplicationData.Current.LocalFolder.CreateFolderAsync( string.Format(CultureInfo.InvariantCulture, "cache\\{0}", CacheID), CreationCollisionOption.OpenIfExists).AsTask().Result; var factory = new SonicApiDataSourceFactory(this); MusicFolders = factory.GenerateDefaultSonicApiDataSource<IEnumerable<MusicFolder>, SonicAPI.RESTSchema.MusicFolders>( x => Task.FromResult(x.musicFolder.Select(y => new MusicFolder(this, y.id.ToString(CultureInfo.InvariantCulture), y.name))), () => Task.FromResult(Query.GetMusicFoldersQuery())); Indexes = factory.GenerateDefaultSonicApiDataSource<IEnumerable<Index>, string, SonicAPI.RESTSchema.Indexes>( x => Task.FromResult(x.index.Select(index => new Index(this, index.name, index.artist.Select(a => a.id).ToList()))), x => Task.FromResult(Query.GetIndexesQuery(x))); MusicDirectory = factory.GenerateDefaultSonicApiDataSource<MusicDirectory, string, SonicAPI.RESTSchema.Directory>( x => Task.FromResult(new MusicDirectory(this, x.id, x.name, x.child)), x => Task.FromResult(Query.GetMusicDirectoryQuery(x))); CoverArt = new MemoryCache<BitmapImage, string>( new ConvertingDataSource<byte[], BitmapImage, string, string>( x => x.ConvertToBitmapImageAsync(), Task.FromResult, new FileCache<byte[], string, ByteArrayFileConverter>(CacheFolder.CreateFolderAsync("coverArt", CreationCollisionOption.OpenIfExists).AsTask().Result, new CoverArtDataSource(Query)))); }
public void Constructor_SetEntryLifetime_Success() { TimeSpan entryLifetime = TimeSpan.FromMinutes(1); var cache = new MemoryCache<int, string>(entryLifetime); Assert.AreEqual(entryLifetime, cache.EntryLifetime); Assert.AreEqual(DefaultMaxSize, cache.MaxSize); }
public void Removes_an_object_from_the_cache_by_its_key() { ICache caching = new MemoryCache(mockLogger); bool removed = caching.Remove("firstItem"); Assert.IsTrue(removed); }
public void Add_AddMoreThanAvailable_Success() { var cache = new MemoryCache<int, string>(); for (int i = 0; i < DefaultMaxSize; ++i) { KeyValuePair<int, string>? removed; bool wasSaved = cache.Save(i, i.ToString(), out removed); Assert.IsTrue(wasSaved); Assert.IsNull(removed); } List<KeyValuePair<int, string>> values = cache.GetAll().ToList(); Assert.AreEqual(DefaultMaxSize, values.Count); for (int i = 0; i < DefaultMaxSize; ++i) { KeyValuePair<int, string>? removed; bool wasAdded = cache.Save(i, i.ToString(), out removed); Assert.IsTrue(wasAdded); Assert.IsNotNull(removed); Assert.AreEqual(i, removed.Value.Key); Assert.AreEqual(i.ToString(), removed.Value.Value); } values = cache.GetAll().ToList(); Assert.AreEqual(DefaultMaxSize, values.Count); }
public void TileFetcherShouldBehaveProperlyWithNoisyResponses() { // Arrange var schema = new GlobalSphericalMercator(); var tileSource = new TileSource(new SometimesFailingTileProvider(), schema); var memoryCache = new MemoryCache<Feature>(14, 17); var tileFetcher = new TileFetcher(tileSource, memoryCache); var random = new Random(31747074); // Act for (int i = 0; i < 100; i++) { var randomLevel = "5"; var randomCol = random.Next(schema.GetMatrixWidth(randomLevel)); var randomRow = random.Next(schema.GetMatrixHeight(randomLevel)); var tileRange = new TileRange(randomCol - 2, randomRow - 2, 5, 5); var unitsPerPixel = schema.Resolutions[randomLevel].UnitsPerPixel; var extent = TileTransform.TileToWorld(tileRange, randomLevel, schema); tileFetcher.ViewChanged(TileTransform.TileToWorld(tileRange, randomLevel, schema).ToBoundingBox(),unitsPerPixel ); var tileInfos = schema.GetTileInfos(extent, randomLevel); foreach (var tileInfo in tileInfos) { var tiles = memoryCache.Find(tileInfo.Index); } } // Assert Assert.True(memoryCache.TileCount == 0); }
public void CachedClientCachesResultsInMemoryCache() { // Arrange var uri = new Uri(@"http://nuget.org"); var webResponse = new Mock<WebResponse>(MockBehavior.Strict); webResponse.Setup(s => s.ResponseUri).Returns(uri) .Verifiable(); var client = new Mock<HttpClient>(MockBehavior.Strict, uri); client.Setup(s => s.GetResponse()).Returns(webResponse.Object); var memoryCache = new MemoryCache(); var redirectedClient1 = new Mock<RedirectedHttpClient>(uri, memoryCache) { CallBase = true }; redirectedClient1.Setup(r => r.EnsureClient()).Returns(client.Object).Verifiable(); var redirectedClient2 = new Mock<RedirectedHttpClient>(uri, memoryCache) { CallBase = true }; // Act var result1 = redirectedClient1.Object.CachedClient; var result2 = redirectedClient2.Object.CachedClient; // Assert Assert.Same(result1, result2); redirectedClient1.Verify(r => r.EnsureClient(), Times.Once()); redirectedClient2.Verify(r => r.EnsureClient(), Times.Never()); }
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 tasks = new List<Task>(); for (int threads = 0; threads < 100; threads++) { var task = Task.Run(() => { for (int i = 0; i < 110000; i++) { cache.GetOrSet(key, context => { context.SetAbsoluteExpiration(TimeSpan.FromMilliseconds(50)); // Fake expensive object creation. for (int j = 0; j < 1000000; j++) { } return new object(); }); } }); tasks.Add(task); } Console.WriteLine("Running"); Task.WaitAll(tasks.ToArray()); Console.WriteLine("Done"); }
/// <summary> /// Creates a new instance of the <see cref="CalculationEngine"/> class. /// </summary> /// <param name="cultureInfo"> /// The <see cref="CultureInfo"/> required for correctly reading floating poin numbers. /// </param> /// <param name="executionMode">The execution mode that must be used for formula execution.</param> /// <param name="cacheEnabled">Enable or disable caching of mathematical formulas.</param> /// <param name="optimizerEnabled">Enable or disable optimizing of formulas.</param> public CalculationEngine(CultureInfo cultureInfo, ExecutionMode executionMode, bool cacheEnabled, bool optimizerEnabled) { this.executionFormulaCache = new MemoryCache<string, Func<Dictionary<string, double>, double>>(); this.FunctionRegistry = new FunctionRegistry(false); this.ConstantRegistry = new ConstantRegistry(false); this.cultureInfo = cultureInfo; this.cacheEnabled = cacheEnabled; this.optimizerEnabled = optimizerEnabled; if (executionMode == ExecutionMode.Interpreted) executor = new Interpreter(); else if (executionMode == ExecutionMode.Compiled) executor = new DynamicCompiler(); else throw new ArgumentException(string.Format("Unsupported execution mode \"{0}\".", executionMode), "executionMode"); optimizer = new Optimizer(new Interpreter()); // We run the optimizer with the interpreter // Register the default constants of Jace.NET into the constant registry RegisterDefaultConstants(); // Register the default functions of Jace.NET into the function registry RegisterDefaultFunctions(); }
public void ClientIsNotCachedIfExceptionOccursWhen() { // Arrange var uri = new Uri(@"http://nuget.org"); var webResponse = new Mock<WebResponse>(MockBehavior.Strict); webResponse.Setup(s => s.ResponseUri).Returns(uri) .Verifiable(); var client = new Mock<HttpClient>(MockBehavior.Strict, uri); client.Setup(s => s.GetResponse()).Returns(webResponse.Object); var memoryCache = new MemoryCache(); var redirectedClient1 = new Mock<RedirectedHttpClient>(uri, memoryCache) { CallBase = true }; redirectedClient1.Setup(r => r.EnsureClient()).Throws(new Exception("Na na na na na")).Verifiable(); var redirectedClient2 = new Mock<RedirectedHttpClient>(uri, memoryCache) { CallBase = true }; redirectedClient2.Setup(r => r.EnsureClient()).Returns(client.Object); // Act and Assert ExceptionAssert.Throws<Exception>(() => redirectedClient1.Object.CachedClient.ToString(), "Na na na na na"); var result2 = redirectedClient2.Object.CachedClient; // Assert Assert.Same(client.Object, result2); redirectedClient1.Verify(r => r.EnsureClient(), Times.Once()); redirectedClient2.Verify(r => r.EnsureClient(), Times.Once()); }
public void Test002_NoEvictionCacheJustKeepsGrowing() { var noEvictionCache = new MemoryCache<int, int>(); Assert.AreEqual(noEvictionCache.Capacity, AbstractCache.DefaultCapacity); noEvictionCache.Add(19, 19); noEvictionCache.Add(1, 1); noEvictionCache.Add(6, 6); noEvictionCache.Add(2, 2); noEvictionCache.Add(16, 16); noEvictionCache.Add(5, 5); noEvictionCache.Add(18, 18); noEvictionCache.Add(7, 7); noEvictionCache.Add(15, 15); noEvictionCache.Add(4, 4); noEvictionCache.Add(14, 14); noEvictionCache.Add(9, 9); noEvictionCache.Add(13, 13); noEvictionCache.Add(17, 17); noEvictionCache.Add(12, 12); noEvictionCache.Add(3, 3); Assert.AreEqual(noEvictionCache.Count, 16); noEvictionCache.Add(10, 10); noEvictionCache.Add(11, 11); noEvictionCache.Add(8, 8); Assert.AreEqual(noEvictionCache.Count, 19); var expectedArray = Enumerable.Range(1, 19).ToArray(); var cacheArray = noEvictionCache.OrderBy(i => i).ToArray(); Assert.AreEqual(expectedArray, cacheArray); }
private static void DrawRecursive(Graphics graphics, ITileSchema schema, IViewport viewport, MemoryCache<Feature> cache, Extent extent, int level) { var tileInfos = schema.GetTilesInView(extent, level); foreach (TileInfo info in tileInfos) { var feature = cache.Find(info.Index); if (feature == null) { if (level > 0) DrawRecursive(graphics, schema, viewport, cache, info.Extent.Intersect(extent), level - 1); } else { var image = ((IRaster)feature.Geometry).Data; RectangleF dest = WorldToView(info.Extent, viewport); dest = RoundToPixel(dest); RectangleF clip = WorldToView(extent, viewport); clip = RoundToPixel(clip); if (!Contains(clip, dest)) { clip = Intersect(clip, dest); if (clip.IsEmpty) continue; DrawImage(graphics, new Bitmap(image), dest, clip); } else { //Not using a clip at all sometimes performs better than using screenwide clip. DrawImage(graphics, new Bitmap(image), dest); } } } }
public void Constructor_SetCacheMaxSize_Success() { const int maxSize = 1024; var cache = new MemoryCache<int, string>(maxSize); Assert.AreEqual(DefaultEntryLifetime, cache.EntryLifetime); Assert.AreEqual(maxSize, cache.MaxSize); }
private static void RenderTile(WriteableBitmap bitmap, ITileSchema schema, IViewport viewport, MemoryCache<Feature> memoryCache) { int level = BruTile.Utilities.GetNearestLevel(schema.Resolutions, viewport.Resolution); var tiles = schema.GetTilesInView(viewport.Extent.ToExtent(), level); foreach (TileInfo tile in tiles) { var p = NativeCache.Find(tile.Index); if (p != null) { bitmap.Render(p, null); continue; } var image = memoryCache.Find(tile.Index); if (image != null) { Rect dest = WorldToView(tile.Extent, viewport); dest = GeometryRenderer.RoundToPixel(dest); //See here the clumsy way to write a bitmap in SL/WPF var path = new System.Windows.Shapes.Path(); path.Data = new RectangleGeometry { Rect = dest }; var bitmapImage = new BitmapImage(); bitmapImage.SetSource(((IRaster)image.Geometry).Data); path.Fill = new ImageBrush { ImageSource = bitmapImage }; path.CacheMode = new BitmapCache(); bitmap.Render(path, null); } } }
public void Gets_the_object_from_the_cache() { ICache caching = new MemoryCache(mockLogger); MyClass mc = caching.Get<MyClass>("firstItem"); Assert.IsNotNull(mc); }
public void CacheSet_Pass() { ICache cache = new MemoryCache(); cache.Set("Item", "Value"); var item = cache.Get<String>("Item"); Assert.AreEqual(item, "Value"); }
public void Test002_CannotSetThePolicyOfANonEmptyCache() { var nonEmptyCache = new MemoryCache<int, int>(); nonEmptyCache.SetPolicy(typeof(NoEvictionPolicy<,>)); nonEmptyCache.Add(1, 1); nonEmptyCache.Policy = null; }
public void Render(Canvas canvas, TileSchema schema, ITransform transform, MemoryCache<MemoryStream> cache, List<Marker> markerCache) { CollapseAll(canvas); int level = BruTile.Utilities.GetNearestLevel(schema.Resolutions, transform.Resolution); DrawRecursive(canvas, schema, transform, cache, transform.Extent, level); DrawMarkers(canvas, schema, transform, markerCache, transform.Extent, level); RemoveCollapsed(canvas); }
public void AddGenericTest() { var adapter = new MemoryCache(); var value = new { Some = "string" }; adapter.Add("asdf", value); adapter.Get<object>("asdf").Should().Be(value); }
public InMemoryPublicKeyCache( MemoryCache cache ) { if( cache == null ) { throw new ArgumentNullException( "cache" ); } m_cache = cache; }
public ApplicationPage() { this.navigationHelper = new NavigationHelper(this); this.navigationHelper.LoadState += this.NavigationHelper_LoadState; //Done this.navigationHelper.SaveState += this.NavigationHelper_SaveState; //Done this.NavigationCacheMode = Windows.UI.Xaml.Navigation.NavigationCacheMode.Disabled; Cache = new MemoryCache(); TitleTemplateSelector = new TitleOnlyTitleBarTemplateSelector(); }
public void Adding_an_object_to_the_cache_by_key() { ICache caching = new MemoryCache(mockLogger); var mc = new MyClass(); bool added = caching.Add("firstItem", mc); Assert.IsTrue(added); }
public void Adding_an_object_with_an_sliding_expiration_date() { ICache caching = new MemoryCache(mockLogger); var mc = new MyClass(); bool added = caching.AddAndKeepWhileUsed("thirdItem", mc, new TimeSpan(0, 2, 0)); Assert.IsTrue(added); }
public void Adding_an_object_with_an_absolute_expiration_date() { ICache caching = new MemoryCache(mockLogger); var mc = new MyClass(); bool added = caching.AddAndKeepFor("secondItem", mc, new TimeSpan(0, 2, 0)); Assert.IsTrue(added); }
public void TestCacheCleanupBiggerThanCacheSize() { MemoryCache<string, int> cache = new MemoryCache<string, int>(1, 3); cache.GetOrAdd("test1", k => 1); cache.GetOrAdd("test2", k => 2); cache.GetOrAdd("test3", k => 3); Assert.IsTrue(cache.ContainsKey("test3")); Assert.AreEqual(1, cache.Count); }
public TileFetcher(ITileSource tileSource, MemoryCache<Feature> memoryCache, int maxRetries = 2) { if (tileSource == null) throw new ArgumentException("TileProvider can not be null"); this.tileSource = tileSource; if (memoryCache == null) throw new ArgumentException("MemoryCache can not be null"); this.memoryCache = memoryCache; this.maxRetries = maxRetries; }
public void TestCacheCleanupOnlyAdd() { MemoryCache<string, int> cache = new MemoryCache<string, int>(3, 1); cache.GetOrAdd("test1", k => 1); cache.GetOrAdd("test2", k => 2); cache.GetOrAdd("test3", k => 3); cache.GetOrAdd("test4", k => 3); Assert.IsFalse(cache.ContainsKey("test1")); Assert.AreEqual(3, cache.Count); }
public MemoryCacheContainer (MemoryCache owner, int id, MemoryCachePerformanceCounters perfCounters) { if (owner == null) throw new ArgumentNullException ("owner"); this.owner = owner; this.ID = id; this.perfCounters = perfCounters; cache = new SortedDictionary <string, MemoryCacheEntry> (); lru = new MemoryCacheLRU (this, DEFAULT_LRU_LOWER_BOUND); }
public TileFetcher(ITileSource tileSource, MemoryCache<Feature> memoryCache, int maxAttempts = DefaultMaxAttempts, int maxThreads = DefaultMaxThreads, IFetchStrategy strategy = null) { if (tileSource == null) throw new ArgumentException("TileProvider can not be null"); if (memoryCache == null) throw new ArgumentException("MemoryCache can not be null"); _tileSource = tileSource; _memoryCache = memoryCache; _maxAttempts = maxAttempts; _maxThreads = maxThreads; _strategy = strategy ?? new FetchStrategy(); }
public void LoadFromUnderlyingStoreIfNotCached() { var aggregate = new FakeAggregate(); var decoratedAggregateStore = new Mock<IStoreAggregates>(); var memoryCache = new MemoryCache(Guid.NewGuid().ToString()); var cachedAggregateStore = new CachedAggregateStore(decoratedAggregateStore.Object, TimeSpan.FromMinutes(1), memoryCache); decoratedAggregateStore.Setup(mock => mock.Get(typeof(FakeAggregate), aggregate.Id)).Returns(aggregate); cachedAggregateStore.Get(typeof(FakeAggregate), aggregate.Id); decoratedAggregateStore.Verify(mock => mock.Get(typeof(FakeAggregate), aggregate.Id), Times.Once()); }
public void UseCachedAggregateIfAvailable() { var aggregate = new FakeAggregate(); var decoratedAggregateStore = new Mock<IStoreAggregates>(); var memoryCache = new MemoryCache(Guid.NewGuid().ToString()); var cachedAggregateStore = new CachedAggregateStore(decoratedAggregateStore.Object, TimeSpan.FromMinutes(1), memoryCache); memoryCache.Add(aggregate.CacheKey, aggregate, new CacheItemPolicy()); Assert.Same(aggregate, cachedAggregateStore.Get(typeof(FakeAggregate), aggregate.Id)); decoratedAggregateStore.Verify(mock => mock.Get(typeof(FakeAggregate), aggregate.Id), Times.Never()); }
public void RegisterServices(IServiceCollection services, IConfiguration configuration) { var memoryCache = new MemoryCache(Options.Create(new MemoryCacheOptions())); services.AddSingleton <IMemoryCache>(memoryCache); services.Configure <AzureAdConfiguration>(options => { configuration.GetSection("AzureAd").Bind(options); }); services.Configure <ServicesConfiguration>(options => { configuration.GetSection("VhServices").Bind(options); }); var serviceConfiguration = new ServicesConfiguration(); configuration.GetSection("VhServices").Bind(serviceConfiguration); services.AddScoped <IAzureTokenProvider, AzureTokenProvider>(); services.AddLogging(builder => builder.AddApplicationInsights(configuration["ApplicationInsights:InstrumentationKey"]) ); services.AddScoped <ICloseConferenceService, CloseConferenceService>(); services.AddScoped <IClearConferenceChatHistoryService, ClearConferenceChatHistoryService>(); services.AddScoped <IAnonymiseHearingsConferencesDataService, AnonymiseHearingsConferencesDataService>(); services.AddScoped <IRemoveHeartbeatsForConferencesService, RemoveHeartbeatsForConferencesService>(); services.AddScoped <IELinksService, ELinksService>(); services.AddTransient <VideoServiceTokenHandler>(); services.AddTransient <BookingsServiceTokenHandler>(); services.AddTransient <UserServiceTokenHandler>(); services.AddTransient <ELinksApiDelegatingHandler>(); services.AddHttpClient <IVideoApiClient, VideoApiClient>() .AddHttpMessageHandler <VideoServiceTokenHandler>() .AddTypedClient(httpClient => { var client = VideoApiClient.GetClient(httpClient); client.BaseUrl = serviceConfiguration.VideoApiUrl; client.ReadResponseAsString = true; return((IVideoApiClient)client); }); services.AddHttpClient <IBookingsApiClient, BookingsApiClient>() .AddHttpMessageHandler <BookingsServiceTokenHandler>() .AddTypedClient(httpClient => { var client = BookingsApiClient.GetClient(httpClient); client.BaseUrl = serviceConfiguration.BookingsApiUrl; client.ReadResponseAsString = true; return((IBookingsApiClient)client); }); services.AddHttpClient <IUserApiClient, UserApiClient>() .AddHttpMessageHandler <UserServiceTokenHandler>() .AddTypedClient(httpClient => { var client = UserApiClient.GetClient(httpClient); client.BaseUrl = serviceConfiguration.UserApiUrl; client.ReadResponseAsString = true; return((IUserApiClient)client); }); services.AddHttpClient <IELinksApiClient, ELinksApiClient>() .AddHttpMessageHandler <ELinksApiDelegatingHandler>() .AddTypedClient(httpClient => { var eLinksApiClient = new ELinksApiClient(httpClient) { BaseUrl = serviceConfiguration.ELinksApiUrl }; return((IELinksApiClient)eLinksApiClient); }); }
/// <summary> /// Runs a PowerShell script with parameters and prints the resulting pipeline objects to the console output. /// </summary> /// <param name="scriptId">The script file contents.</param> /// <param name="scriptParameters">A dictionary of parameter names and parameter values.</param> /// <param name="outputHandler">The outputHandler to send the script output to.</param> private async Task StreamPowerShell(string scriptId, Dictionary <string, object> scriptParameters, Action <object> outputHandler) { string cacheKey = $"{Context.ConnectionId}|CancellationTokenSource"; try { var script = ScriptService.GetScript(scriptId); outputHandler(new OutputRecord(OutputLevelName.System, "Loading script...")); Logger.Log(LogLevel.Information, $"{Context.User.Identity.Name} attempting to run {script.Name}"); string scriptContents = script.GetContents(); // Setup a custom runspace pool if configured on the script if (script.Runspace != null) { InitializeRunspaces(script.Runspace); } // create a new hosted PowerShell instance potentially with a custom runspace. // wrap in a using statement to ensure resources are cleaned up. using (PowerShell ps = PowerShell.Create()) { // use the runspace pool, if it was created. if (RsPool != null) { ps.RunspacePool = RsPool; } // specify the script code to run. ps.AddScript(scriptContents); // specify the parameters to pass into the script. ps.AddParameters(scriptParameters); // Subscribe to events from output var output = new PSDataCollection <PSObject>(); output.DataAdded += (object sender, DataAddedEventArgs e) => WriteOutput <PSObject>(sender, e, outputHandler); // subscribe to events from some of the streams /// Handles data-added events for the error stream. /// Note: Uncaught terminating errors will stop the pipeline completely. /// Non-terminating errors will be written to this stream and execution will continue. ps.Streams.Error.DataAdded += (object sender, DataAddedEventArgs e) => WriteOutput <ErrorRecord>(sender, e, outputHandler); ps.Streams.Warning.DataAdded += (object sender, DataAddedEventArgs e) => WriteOutput <WarningRecord>(sender, e, outputHandler); /// Handles data-added events for the information stream. /// Note: Write-Host and Write-Information messages will end up in the information stream. ps.Streams.Information.DataAdded += (object sender, DataAddedEventArgs e) => WriteOutput <InformationRecord>(sender, e, outputHandler); ps.Streams.Progress.DataAdded += (object sender, DataAddedEventArgs e) => WriteOutput <ProgressRecord>(sender, e, outputHandler); ps.Streams.Verbose.DataAdded += (object sender, DataAddedEventArgs e) => WriteOutput <VerboseRecord>(sender, e, outputHandler); ps.Streams.Debug.DataAdded += (object sender, DataAddedEventArgs e) => WriteOutput <DebugRecord>(sender, e, outputHandler); outputHandler(new OutputRecord(OutputLevelName.System, "Beginning script execution...")); // setup our cancellation token for possible use later to cancel CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); // We basically want to cache the cancellationTokenSource until the script finishes (or is canceled) var cacheExpiryOptions = new MemoryCacheEntryOptions { AbsoluteExpiration = DateTime.Now.AddDays(1), Priority = CacheItemPriority.High }; MemoryCache.Set(cacheKey, cancellationTokenSource, cacheExpiryOptions); // NOTE: the 'await' call is gone here so we can access the task object. Task <PSDataCollection <PSObject> > asyncTask = ps.InvokeAsync(); asyncTask.Wait(cancellationTokenSource.Token); // Wait on the task until natural completion OR cancel token fires. output = asyncTask.Result; // this object should contain the original PSObject results (pipeline output). } } catch (Exception ex) { Logger.Log(LogLevel.Error, ex, ex.Message); outputHandler(new OutputRecord(OutputLevelName.Error, ex.Message)); } finally { outputHandler(new OutputRecord(OutputLevelName.System, "Script execution ended.")); MemoryCache.Remove(cacheKey); } }
public static object GetValue(string key) { MemoryCache memoryCache = Default; return(memoryCache.Get(key)); }
/// <summary> /// Инициализация сервиса кэша пользователей. /// </summary> public UserCache() { memoryCache = MemoryCache.Default; }
public static void Delete(string key) { MemoryCache memoryCache = Default; memoryCache.Remove(key); }
// This method gets called by the runtime. Use this method to add services to the container. /// <summary> /// ConfigureServices 方法 /// </summary> /// <param name="services"></param> public IServiceProvider ConfigureServices(IServiceCollection services) { services.AddMvc(); //将 TService 中指定的类型的范围服务添加到实现 services.AddScoped <ICaching, MemoryCaching>();//记得把缓存注入!!! #region 配置信息 //Blog.Core.Repository.BaseDBConfig.ConnectionString = Configuration.GetSection("AppSettings:SqlServerConnection").Value; #endregion #region Swagger services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info { Version = "v0.1.0", Title = "Blog.Core API", Description = "框架说明文档", TermsOfService = "None", Contact = new Swashbuckle.AspNetCore.Swagger.Contact { Name = "Blog.Core", Email = "*****@*****.**", Url = "https://www.jianshu.com/u/94102b59cc2a" } }); //就是这里 #region 读取xml信息 var basePath = PlatformServices.Default.Application.ApplicationBasePath; var xmlPath = Path.Combine(basePath, "Blog.Core.xml"); //这个就是刚刚配置的xml文件名 var xmlModelPath = Path.Combine(basePath, "Blog.Core.Model.xml"); //这个就是Model层的xml文件名 c.IncludeXmlComments(xmlPath, true); //默认的第二个参数是false,这个是controller的注释,记得修改 c.IncludeXmlComments(xmlModelPath); #endregion #region Token绑定到ConfigureServices //添加header验证信息 //c.OperationFilter<SwaggerHeader>(); var security = new Dictionary <string, IEnumerable <string> > { { "Blog.Core", new string[] { } }, }; c.AddSecurityRequirement(security); //方案名称“Blog.Core”可自定义,上下一致即可 c.AddSecurityDefinition("Blog.Core", new ApiKeyScheme { Description = "JWT授权(数据将在请求头中进行传输) 直接在下框中输入{token}\"", Name = "Authorization", //jwt默认的参数名称 In = "header", //jwt默认存放Authorization信息的位置(请求头中) Type = "apiKey" }); #endregion }); #endregion #region Token服务注册 services.AddSingleton <IMemoryCache>(factory => { var cache = new MemoryCache(new MemoryCacheOptions()); return(cache); }); services.AddAuthorization(options => { options.AddPolicy("Admin", policy => policy.RequireClaim("AdminType").Build());//注册权限管理,可以自定义多个 }); #endregion #region AutoFac //实例化 AutoFac 容器 var builder = new ContainerBuilder(); //注册要通过反射创建的组件 //builder.RegisterType<AdvertisementServices>().As<IAdvertisementServices>(); builder.RegisterType <BlogCacheAOP>();//可以直接替换其他拦截器 var assemblysServices = Assembly.Load("Blog.Core.Services"); //builder.RegisterAssemblyTypes(assemblysServices).AsImplementedInterfaces();//指定已扫描程序集中的类型注册为提供所有其实现的接口。 builder.RegisterAssemblyTypes(assemblysServices) .AsImplementedInterfaces() .InstancePerLifetimeScope() .EnableInterfaceInterceptors() //引用Autofac.Extras.DynamicProxy; .InterceptedBy(typeof(BlogCacheAOP)); //允许将拦截器服务的列表分配给注册。可以直接替换其他拦截器 var assemblysRepository = Assembly.Load("Blog.Core.Repository"); builder.RegisterAssemblyTypes(assemblysRepository).AsImplementedInterfaces(); //将services填充到Autofac容器生成器中 builder.Populate(services); //使用已进行的组件登记创建新容器 var ApplicationContainer = builder.Build(); #endregion return(new AutofacServiceProvider(ApplicationContainer));//第三方IOC接管 core内置DI容器 }
internal void ClearCache() { ViewLookupCache = new MemoryCache(new MemoryCacheOptions()); }
/// <summary> /// Creates a memory cache provider, storing each result in a MemoryCache for the specified duration. /// </summary> /// <param name="cacheDuration">The duration to cache each profiler, before it expires from cache.</param> public MemoryCacheStorage(TimeSpan cacheDuration) { _cache = new MemoryCache("MiniProfilerCache"); CacheDuration = cacheDuration; }
public async Task ABP_New_Loaded_Device_With_Fcnt_1_Or_0_Should_Reset_Fcnt_And_Send_To_IotHub( string twinGatewayID, uint payloadFcntUp, uint?deviceTwinFcntUp, uint?deviceTwinFcntDown) { var simulatedDevice = new SimulatedDevice(TestDeviceInfo.CreateABPDevice(1, gatewayID: null)); var devEUI = simulatedDevice.LoRaDevice.DeviceID; var devAddr = simulatedDevice.LoRaDevice.DevAddr; // message will be sent LoRaDeviceTelemetry loRaDeviceTelemetry = null; this.LoRaDeviceClient.Setup(x => x.SendEventAsync(It.IsNotNull <LoRaDeviceTelemetry>(), null)) .Callback <LoRaDeviceTelemetry, Dictionary <string, string> >((t, _) => loRaDeviceTelemetry = t) .ReturnsAsync(true); // C2D message will be checked this.LoRaDeviceClient.Setup(x => x.ReceiveAsync(It.IsNotNull <TimeSpan>())) .ReturnsAsync((Message)null); // twin will be loaded var initialTwin = new Twin(); initialTwin.Properties.Desired[TwinProperty.DevEUI] = devEUI; initialTwin.Properties.Desired[TwinProperty.AppEUI] = simulatedDevice.LoRaDevice.AppEUI; initialTwin.Properties.Desired[TwinProperty.AppKey] = simulatedDevice.LoRaDevice.AppKey; initialTwin.Properties.Desired[TwinProperty.NwkSKey] = simulatedDevice.LoRaDevice.NwkSKey; initialTwin.Properties.Desired[TwinProperty.AppSKey] = simulatedDevice.LoRaDevice.AppSKey; initialTwin.Properties.Desired[TwinProperty.DevAddr] = devAddr; if (twinGatewayID != null) { initialTwin.Properties.Desired[TwinProperty.GatewayID] = twinGatewayID; } initialTwin.Properties.Desired[TwinProperty.SensorDecoder] = simulatedDevice.LoRaDevice.SensorDecoder; if (deviceTwinFcntDown.HasValue) { initialTwin.Properties.Reported[TwinProperty.FCntDown] = deviceTwinFcntDown.Value; } if (deviceTwinFcntUp.HasValue) { initialTwin.Properties.Reported[TwinProperty.FCntUp] = deviceTwinFcntUp.Value; } this.LoRaDeviceClient.Setup(x => x.GetTwinAsync()).ReturnsAsync(initialTwin); // twin will be updated with new fcnt int?fcntUpSavedInTwin = null; int?fcntDownSavedInTwin = null; var shouldSaveTwin = (deviceTwinFcntDown ?? 0) != 0 || (deviceTwinFcntUp ?? 0) != 0; if (shouldSaveTwin) { this.LoRaDeviceClient.Setup(x => x.UpdateReportedPropertiesAsync(It.IsNotNull <TwinCollection>())) .Callback <TwinCollection>((t) => { fcntUpSavedInTwin = (int)t[TwinProperty.FCntUp]; fcntDownSavedInTwin = (int)t[TwinProperty.FCntDown]; }) .ReturnsAsync(true); } // multi gateway will reset the fcnt if (shouldSaveTwin) { this.LoRaDeviceApi.Setup(x => x.ABPFcntCacheResetAsync(devEUI)) .ReturnsAsync(true); } // device api will be searched for payload this.LoRaDeviceApi.Setup(x => x.SearchByDevAddrAsync(devAddr)) .ReturnsAsync(new SearchDevicesResult(new IoTHubDeviceInfo(devAddr, devEUI, "abc").AsList())); var memoryCache = new MemoryCache(new MemoryCacheOptions()); var deviceRegistry = new LoRaDeviceRegistry(this.ServerConfiguration, memoryCache, this.LoRaDeviceApi.Object, this.LoRaDeviceFactory); // Send to message processor var messageDispatcher = new MessageDispatcher( this.ServerConfiguration, deviceRegistry, this.FrameCounterUpdateStrategyProvider); // sends unconfirmed message var unconfirmedMessagePayload = simulatedDevice.CreateUnconfirmedDataUpMessage("hello", fcnt: payloadFcntUp); var rxpk = unconfirmedMessagePayload.SerializeUplink(simulatedDevice.AppSKey, simulatedDevice.NwkSKey).Rxpk[0]; var request = this.CreateWaitableRequest(rxpk); messageDispatcher.DispatchRequest(request); Assert.True(await request.WaitCompleteAsync()); Assert.Null(request.ResponseDownlink); // Ensure that a telemetry was sent Assert.NotNull(loRaDeviceTelemetry); // Ensure that the device twins were saved if (shouldSaveTwin) { Assert.NotNull(fcntDownSavedInTwin); Assert.NotNull(fcntUpSavedInTwin); Assert.Equal(0, fcntDownSavedInTwin.Value); Assert.Equal(0, fcntUpSavedInTwin.Value); } // verify that the device in device registry has correct properties and frame counters var devicesForDevAddr = deviceRegistry.InternalGetCachedDevicesForDevAddr(devAddr); Assert.Single(devicesForDevAddr); Assert.True(devicesForDevAddr.TryGetValue(devEUI, out var loRaDevice)); Assert.Equal(devAddr, loRaDevice.DevAddr); Assert.Equal(devEUI, loRaDevice.DevEUI); Assert.True(loRaDevice.IsABP); Assert.Equal(payloadFcntUp, loRaDevice.FCntUp); Assert.Equal(0U, loRaDevice.FCntDown); if (payloadFcntUp == 0) { Assert.False(loRaDevice.HasFrameCountChanges); // no changes } else { Assert.True(loRaDevice.HasFrameCountChanges); // should have changes! } this.LoRaDeviceClient.VerifyAll(); this.LoRaDeviceApi.VerifyAll(); }
public MemoryCacheTest() { _cache = MemoryCache.Default; }
/// <summary>A MemoryCache extension method that adds an or get existing.</summary> /// <typeparam name="TValue">Type of the value.</typeparam> /// <param name="cache">The cache to act on.</param> /// <param name="key">The key.</param> /// <param name="value">The value.</param> /// <returns>A TValue.</returns> public static TValue AddOrGetExisting <TValue>(this MemoryCache cache, string key, TValue value) { object item = cache.AddOrGetExisting(key, value, new CacheItemPolicy()) ?? value; return((TValue)item); }
public void Dispose() { MemoryCache.Dispose(); SqlCache.Dispose(); }
public EventEnricherTests() { var cache = new MemoryCache(Options.Create(new MemoryCacheOptions())); sut = new EventEnricher(cache, userResolver); }
protected virtual async Task ShowPlaceholder(string path, string key, ImageSource source, bool isLoadingPlaceholder) { if (Parameters.Preload) { return; } if (!await TryLoadFromMemoryCacheAsync(key, false, false, isLoadingPlaceholder).ConfigureAwait(false)) { try { var customResolver = isLoadingPlaceholder ? Parameters.CustomLoadingPlaceholderDataResolver : Parameters.CustomErrorPlaceholderDataResolver; var loadResolver = customResolver ?? DataResolverFactory.GetResolver(path, source, Parameters, Configuration); loadResolver = new WrappedDataResolver(loadResolver); DataResolverResult loadImageData; TImageContainer loadImage; if (!await _placeholdersResolveLock.WaitAsync(TimeSpan.FromSeconds(10), CancellationTokenSource.Token).ConfigureAwait(false)) { return; } try { ThrowIfCancellationRequested(); if (await TryLoadFromMemoryCacheAsync(key, false, false, isLoadingPlaceholder).ConfigureAwait(false)) { if (isLoadingPlaceholder) { _isLoadingPlaceholderLoaded = true; Parameters.OnLoadingPlaceholderSet?.Invoke(); } return; } ThrowIfCancellationRequested(); loadImageData = await loadResolver.Resolve(path, Parameters, CancellationTokenSource.Token).ConfigureAwait(false); ThrowIfCancellationRequested(); if (loadImageData.Stream != null) { using (loadImageData.Stream) { loadImage = await GenerateImageAsync(path, source, loadImageData.Stream, loadImageData.ImageInformation, TransformPlaceholders, true).ConfigureAwait(false); } } else { loadImage = loadImageData.ImageContainer as TImageContainer; } if (loadImage != default(TImageContainer)) { MemoryCache.Add(key, loadImageData.ImageInformation, loadImage); } } finally { _placeholdersResolveLock.Release(); } ThrowIfCancellationRequested(); if (isLoadingPlaceholder) { PlaceholderWeakReference = new WeakReference <TImageContainer>(loadImage); } if (Target != null) { await SetTargetAsync(loadImage, false).ConfigureAwait(false); } if (isLoadingPlaceholder) { _isLoadingPlaceholderLoaded = true; Parameters.OnLoadingPlaceholderSet?.Invoke(); } } catch (Exception ex) { if (ex is OperationCanceledException) { throw; } Logger.Error("Setting placeholder failed", ex); } } else if (isLoadingPlaceholder) { _isLoadingPlaceholderLoaded = true; Parameters.OnLoadingPlaceholderSet?.Invoke(); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers(); #region 添加SQL数据库连接 var sqlConnection = Configuration.GetConnectionString("SqlServerConnection"); Console.WriteLine(sqlConnection); services.AddDbContext <UserDbContext>(option => option.UseSqlServer(sqlConnection)); #endregion #region 添加Swagger配置 services.AddSwaggerGen(option => { option.SwaggerDoc("sparktodo", new OpenApiInfo { Version = "v1", Title = "SparkTodo API", Description = "API for SparkTodo", Contact = new OpenApiContact() { Name = "WeihanLi", Email = "*****@*****.**" } }); // include document file option.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, $"{typeof(Startup).Assembly.GetName().Name}.xml"), true); #region Token绑定到ConfigureServices // 开启加权小锁 option.OperationFilter <AddResponseHeadersFilter>(); option.OperationFilter <AppendAuthorizeToSummaryOperationFilter>(); // 在header中添加token,传递到后台 option.OperationFilter <SecurityRequirementsOperationFilter>(); // Jwt Bearer 认证,必须是 oauth2 option.AddSecurityDefinition("oauth2", new OpenApiSecurityScheme { Description = "JWT授权(数据将在请求头中进行传输) 直接在下框中输入Bearer {token}(注意两者之间是一个空格)\"", Name = "Authorization", //jwt默认的参数名称 In = ParameterLocation.Header, //jwt默认存放Authorization信息的位置(请求头中) Type = SecuritySchemeType.ApiKey }); #endregion }); #endregion #region 注册Mapper服务 services.AddAutoMapper(typeof(ServiceProfiles)); #endregion #region CORS services.AddCors(c => { //一般采用这种方法 c.AddPolicy("LimitRequests", policy => { policy .WithOrigins("http://localhost:8080") .AllowAnyHeader()//Ensures that the policy allows any header. .AllowAnyMethod() .AllowCredentials(); }); }); #endregion #region MVC + GlobalExceptions //注入全局异常捕获 services.AddControllers(o => { // 全局异常过滤 o.Filters.Add(typeof(GlobalExceptionsFilter)); // 全局路由权限公约 o.Conventions.Insert(0, new GlobalRouteAuthorizeConvention()); // 全局路由前缀,统一修改路由 // o.Conventions.Insert(0, new GlobalRoutePrefixFilter(new RouteAttribute(RoutePrefix.Name))); }) //全局配置Json序列化处理 .AddNewtonsoftJson(options => { //忽略循环引用 options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; //不使用驼峰样式的key options.SerializerSettings.ContractResolver = new DefaultContractResolver(); //设置时间格式 //options.SerializerSettings.DateFormatString = "yyyy-MM-dd"; }); #endregion #region 部分服务注入-netcore自带方法 // 缓存注入 services.AddScoped <ICaching, MemoryCaching>(); services.AddSingleton <IMemoryCache>(factory => { var cache = new MemoryCache(new MemoryCacheOptions()); return(cache); }); // log日志注入 services.AddSingleton <ILoggerHelper, LogHelper>(); #endregion #region Authorize 权限认证三步走 #region 参数 //读取配置文件 var audienceConfig = Configuration.GetSection("Audience"); var symmetricKeyAsBase64 = audienceConfig["Secret"]; var keyByteArray = Encoding.ASCII.GetBytes(symmetricKeyAsBase64); var signingKey = new SymmetricSecurityKey(keyByteArray); var signingCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256); //如果要数据库动态绑定,这里先留个空,后边处理器里动态赋值 var permission = new List <PermissionItem>(); //角色与接口的权限要求参数 var permissionRequirement = new PermissionRequirement( "/api/denied", // 拒绝授权的跳转地址(目前无用) permission, ClaimTypes.Role, //基于角色的授权 audienceConfig["Issuer"], //发行人 audienceConfig["Audience"], //听众 signingCredentials, //签名凭据 expiration: TimeSpan.FromSeconds(60 * 60) //接口的过期时间 ); #endregion Console.WriteLine("权限第一步:参数"); #region 授权 //【授权】 services.AddAuthorization(options => { options.AddPolicy(Permissions.Name, policy => policy.Requirements.Add(permissionRequirement)); }); #endregion Console.WriteLine("权限第二步:授权"); #region 认证 // 令牌验证参数 var tokenValidationParameters = new TokenValidationParameters { ValidateIssuerSigningKey = true, IssuerSigningKey = signingKey, ValidateIssuer = true, ValidIssuer = audienceConfig["Issuer"], //发行人 ValidateAudience = true, ValidAudience = audienceConfig["Audience"], //订阅人 ValidateLifetime = true, ClockSkew = TimeSpan.FromSeconds(30), RequireExpirationTime = true, }; services.AddAuthentication("Bearer") .AddJwtBearer(o => { o.TokenValidationParameters = tokenValidationParameters; o.Events = new JwtBearerEvents { OnAuthenticationFailed = context => { // 如果过期,则把<是否过期>添加到,返回头信息中 if (context.Exception.GetType() == typeof(SecurityTokenExpiredException)) { context.Response.Headers.Add("Token-Expired", "true"); } return(Task.CompletedTask); } }; }) .AddScheme <AuthenticationSchemeOptions, ApiResponseHandler>(nameof(ApiResponseHandler), o => { }); services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services.AddScoped <IAuthorizationHandler, PermissionHandler>(); services.AddSingleton(permissionRequirement); #endregion Console.WriteLine("权限第三步:认证"); #endregion }
/// <summary> /// Initializes a new instance of the <see cref="CacheService"/> class using the default <see cref="MemoryCache"/>. /// </summary> public CacheService() { this.memoryCache = MemoryCache.Default; }
public async virtual Task <bool> TryLoadFromMemoryCacheAsync() { try { if (Parameters.Preload && Parameters.CacheType.HasValue && (Parameters.CacheType.Value == CacheType.Disk || Parameters.CacheType.Value == CacheType.None)) { return(false); } ThrowIfCancellationRequested(); bool isFadeAnimationEnabledForCached = Parameters.FadeAnimationForCachedImagesEnabled.HasValue ? Parameters.FadeAnimationForCachedImagesEnabled.Value : Configuration.FadeAnimationForCachedImages; var result = await TryLoadFromMemoryCacheAsync(Key, true, isFadeAnimationEnabledForCached, false).ConfigureAwait(false); if (result) { Logger.Debug(string.Format("Image loaded from cache: {0}", Key)); IsCompleted = true; if (Configuration.ExecuteCallbacksOnUIThread && (Parameters?.OnSuccess != null || Parameters?.OnFinish != null)) { await MainThreadDispatcher.PostAsync(() => { Parameters?.OnSuccess?.Invoke(ImageInformation, LoadingResult.MemoryCache); Parameters?.OnFinish?.Invoke(this); }).ConfigureAwait(false); } else { Parameters?.OnSuccess?.Invoke(ImageInformation, LoadingResult.MemoryCache); Parameters?.OnFinish?.Invoke(this); } } else { ThrowIfCancellationRequested(); // Loading placeholder if enabled if (!_isLoadingPlaceholderLoaded && !string.IsNullOrWhiteSpace(Parameters.LoadingPlaceholderPath)) { await ShowPlaceholder(Parameters.LoadingPlaceholderPath, KeyForLoadingPlaceholder, Parameters.LoadingPlaceholderSource, true).ConfigureAwait(false); } } return(result); } catch (Exception ex) { if (Configuration.ClearMemoryCacheOnOutOfMemory && ex is OutOfMemoryException) { MemoryCache.Clear(); } if (ex is OperationCanceledException) { if (Configuration.VerboseLoadingCancelledLogging) { Logger.Debug(string.Format("Image loading cancelled: {0}", Key)); } } else { Logger.Error(string.Format("Image loading failed: {0}", Key), ex); if (Configuration.ExecuteCallbacksOnUIThread && Parameters?.OnError != null) { await MainThreadDispatcher.PostAsync(() => { Parameters?.OnError?.Invoke(ex); }).ConfigureAwait(false); } else { Parameters?.OnError?.Invoke(ex); } } } return(false); }
public object GetValue(string name) { MemoryCache memoryCache = MemoryCache.Default; return(memoryCache.Get(name)); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { #region Swagger services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Version = "V1.0", Title = "ExampleDemo.Api", Description = "实例演示" }); //读取注释 var basePath = PlatformServices.Default.Application.ApplicationBasePath; var xmlPath = Path.Combine(basePath, "ExampleDemo.Core.xml"); c.IncludeXmlComments(xmlPath, true); //添加header验证信息 //var security = new Dictionary<string, IEnumerable<string>> { { "liang", new string[] { } }, }; ////添加一个必须的全局安全信息,和AddSecurityDefinition方法指定的方案名称要一致,这里是liang //c.AddSecurityRequirement(security); //c.AddSecurityDefinition("liang", new OpenApiSecurityScheme { // Description = "JWT授权(数据将在请求头中进行传输) 参数结构: \"Authorization: liang {token}\"", // Name = "Authorization",//jwt默认的参数名称 // In = ParameterLocation.Header,//jwt默认存放Authorization信息的位置(请求头中) // Type =SecuritySchemeType.ApiKey, // BearerFormat="JWT", // Scheme="liang" //}); //c.AddSecurityRequirement(new OpenApiSecurityRequirement //{ // { // new OpenApiSecurityScheme{ // Reference=new OpenApiReference { // Type=ReferenceType.SecurityScheme, // Id="liang" }},new string[]{ } // } //}); }); #endregion #region MemoryCache services.AddSingleton <IMemoryCache>(factory => { var cache = new MemoryCache(new MemoryCacheOptions()); return(cache); }); #endregion #region JWT认证 //services.AddAuthorization(x => //{ // //options.AddPolicy("System", policy => policy.RequireClaim("SystemType").Build()); // //options.AddPolicy("Client", policy => policy.RequireClaim("ClientType").Build()); // //options.AddPolicy("Admin", policy => policy.RequireClaim("AdminType").Build()); //}); #endregion services.AddControllers(); SqlSugarBase._connectionString = Configuration["connectionString"]; }
public void Update(string name, object value, int minutes) { MemoryCache memoryCache = MemoryCache.Default; memoryCache.Set(name, value, DateTime.Now.AddMinutes(minutes)); }
public static bool Add(string key, object value, DateTimeOffset absExpiration) { MemoryCache memoryCache = Default; return(memoryCache.Set(key, value, absExpiration) == value); }
public CacheHelp(MyMemoryCache memoryCache, IRoleService roleService, IAuthService authService) { _cache = memoryCache.Cache; _roleService = roleService; _authService = authService; }
/// <summary> /// Initializes a new instance of the <see cref="CacheService"/> class. /// </summary> /// <param name="memoryCache">The memory cache.</param> public CacheService(MemoryCache memoryCache) { this.memoryCache = memoryCache; }
public LocalCacheProvider() { MemoryCacheOptions options = new MemoryCacheOptions(); _Cache = new MemoryCache(options); }
/// <summary> /// Construct a new FluentMemoryCache from the specified MemoryCache /// </summary> public FluentMemoryCache(MemoryCache memoryCache) : base(memoryCache) { }
public async Task RunAsync() { LoadingResult loadingResult = LoadingResult.Failed; bool success = false; try { // LOAD IMAGE if (!(await TryLoadFromMemoryCacheAsync().ConfigureAwait(false))) { if (Parameters.DelayInMs.HasValue && Parameters.DelayInMs.Value > 0) { await Task.Delay(Parameters.DelayInMs.Value).ConfigureAwait(false); } else if (!Parameters.Preload && Configuration.DelayInMs > 0) { await Task.Delay(Configuration.DelayInMs).ConfigureAwait(false); } Logger.Debug(string.Format("Generating/retrieving image: {0}", Key)); var resolver = Parameters.CustomDataResolver ?? DataResolverFactory.GetResolver(Parameters.Path, Parameters.Source, Parameters, Configuration); resolver = new WrappedDataResolver(resolver); var imageData = await resolver.Resolve(Parameters.Path, Parameters, CancellationTokenSource.Token).ConfigureAwait(false); loadingResult = imageData.LoadingResult; ImageInformation = imageData.ImageInformation; ImageInformation.SetKey(Key, Parameters.CustomCacheKey); ImageInformation.SetPath(Parameters.Path); ThrowIfCancellationRequested(); // Preload if (Parameters.Preload && Parameters.CacheType.HasValue && Parameters.CacheType.Value == CacheType.Disk) { if (loadingResult == LoadingResult.Internet) { Logger?.Debug(string.Format("DownloadOnly success: {0}", Key)); } success = true; return; } ThrowIfCancellationRequested(); TImageContainer image; if (imageData.Stream != null) { using (imageData.Stream) { image = await GenerateImageAsync(Parameters.Path, Parameters.Source, imageData.Stream, imageData.ImageInformation, true, false).ConfigureAwait(false); } } else { image = imageData.ImageContainer as TImageContainer; } ThrowIfCancellationRequested(); try { BeforeLoading(image, false); if (image != default(TImageContainer) && CanUseMemoryCache) { MemoryCache.Add(Key, imageData.ImageInformation, image); } ThrowIfCancellationRequested(); bool isFadeAnimationEnabled = Parameters.FadeAnimationEnabled ?? Configuration.FadeAnimationEnabled; if (Target != null) { await SetTargetAsync(image, isFadeAnimationEnabled).ConfigureAwait(false); } } finally { AfterLoading(image, false); } } success = true; } catch (Exception ex) { if (ex is OperationCanceledException || ex is ObjectDisposedException) { if (Configuration.VerboseLoadingCancelledLogging) { Logger.Debug(string.Format("Image loading cancelled: {0}", Key)); } } else { if (Configuration.ClearMemoryCacheOnOutOfMemory && ex is OutOfMemoryException) { MemoryCache.Clear(); } Logger.Error(string.Format("Image loading failed: {0}", Key), ex); if (Configuration.ExecuteCallbacksOnUIThread && Parameters?.OnError != null) { await MainThreadDispatcher.PostAsync(() => { Parameters?.OnError?.Invoke(ex); }).ConfigureAwait(false); } else { Parameters?.OnError?.Invoke(ex); } try { // Error placeholder if enabled if (!Parameters.Preload && !string.IsNullOrWhiteSpace(Parameters.ErrorPlaceholderPath)) { await ShowPlaceholder(Parameters.ErrorPlaceholderPath, KeyForErrorPlaceholder, Parameters.ErrorPlaceholderSource, false).ConfigureAwait(false); } } catch (Exception ex2) { if (!(ex2 is OperationCanceledException)) { Logger.Error(string.Format("Image loading failed: {0}", Key), ex); } } } } finally { try { if (CancellationTokenSource?.IsCancellationRequested == false) { CancellationTokenSource.Cancel(); } } catch (Exception) { } IsCompleted = true; using (Parameters) { if (Configuration.ExecuteCallbacksOnUIThread && Parameters?.OnFinish != null) { await MainThreadDispatcher.PostAsync(() => { if (success) { Parameters?.OnSuccess?.Invoke(ImageInformation, loadingResult); } Parameters?.OnFinish?.Invoke(this); }).ConfigureAwait(false); } else { if (success) { Parameters?.OnSuccess?.Invoke(ImageInformation, loadingResult); } Parameters?.OnFinish?.Invoke(this); } ImageService.RemovePendingTask(this); } } }
public InProcessCache(string name) { this.Cache = new MemoryCache(name); }
/// <summary>A TKey extension method that from cache.</summary> /// <typeparam name="TKey">Type of the key.</typeparam> /// <typeparam name="TValue">Type of the value.</typeparam> /// <param name="this">The @this to act on.</param> /// <param name="cache">The cache.</param> /// <param name="valueFactory">The value factory.</param> /// <returns>A TValue.</returns> public static TValue FromCache <TKey, TValue>(this TKey @this, MemoryCache cache, Expression <Func <TKey, TValue> > valueFactory) { string key = string.Concat("Z.Caching.FromCache;", typeof(TKey).FullName, valueFactory.ToString()); return(@this.FromCache(cache, key, valueFactory)); }
/// <summary> /// Clear all items from the cache /// </summary> public void ResetCache() { _cache.Dispose(); _cache = new MemoryCache("CustomCache"); }
public bool Add(string name, object value, int minutes) { MemoryCache memoryCache = MemoryCache.Default; return(memoryCache.Add(name, value, DateTime.Now.AddMinutes(minutes))); }