Пример #1
0
        public async Task Cleanup_ThrowsOnUseAfterDisposal()
        {
            var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, null);

            await DisposeOf(cacheStack);

            await cacheStack.CleanupAsync();
        }
Пример #2
0
        public async Task Cleanup_TwoLayers()
        {
            await using (var cacheStack = new CacheStack(new[] { new MemoryCacheLayer(), new MemoryCacheLayer() }, Array.Empty <ICacheExtension>()))
            {
                for (var i = 0; i < WorkIterations; i++)
                {
                    await cacheStack.SetAsync("Cleanup", 15, TimeSpan.FromDays(1));

                    await cacheStack.CleanupAsync();
                }
            }
        }
Пример #3
0
        public async Task MemoryCacheLayer_CacheStack()
        {
            await using (var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, null))
            {
                //Get 100 misses
                for (var i = 0; i < 100; i++)
                {
                    await cacheStack.GetAsync <int>("GetMiss_" + i);
                }

                var startDate = DateTime.UtcNow.AddDays(-50);

                //Set first 100 (simple type)
                for (var i = 0; i < 100; i++)
                {
                    await cacheStack.SetAsync("Comparison_" + i, new CacheEntry <int>(1, startDate.AddDays(i) + TimeSpan.FromDays(1)));
                }
                //Set last 100 (complex type)
                for (var i = 100; i < 200; i++)
                {
                    await cacheStack.SetAsync("Comparison_" + i, new CacheEntry <RealCostComplexType>(new RealCostComplexType
                    {
                        ExampleString = "Hello World",
                        ExampleNumber = 42,
                        ExampleDate = new DateTime(2000, 1, 1),
                        DictionaryOfNumbers = new Dictionary <string, int>()
                        {
                            { "A", 1 }, { "B", 2 }, { "C", 3 }
                        }
                    }, startDate.AddDays(i - 100) + TimeSpan.FromDays(1)));
                }

                //Get first 50 (simple type)
                for (var i = 0; i < 50; i++)
                {
                    await cacheStack.GetAsync <int>("Comparison_" + i);
                }
                //Get last 50 (complex type)
                for (var i = 150; i < 200; i++)
                {
                    await cacheStack.GetAsync <RealCostComplexType>("Comparison_" + i);
                }

                //Evict middle 100
                for (var i = 50; i < 150; i++)
                {
                    await cacheStack.EvictAsync("Comparison_" + i);
                }

                //Cleanup outer 100
                await cacheStack.CleanupAsync();
            }
        }
        public async Task Cleanup_CleansAllTheLayers()
        {
            var layer1 = new MemoryCacheLayer();
            var layer2 = new MemoryCacheLayer();

            using var cacheStack = new CacheStack(new[] { layer1, layer2 }, Array.Empty <ICacheExtension>());

            var cacheEntry = new CacheEntry <int>(42, DateTime.UtcNow.AddDays(-1));
            await cacheStack.SetAsync("Cleanup_CleansAllTheLayers", cacheEntry);

            Assert.AreEqual(cacheEntry, await layer1.GetAsync <int>("Cleanup_CleansAllTheLayers"));
            Assert.AreEqual(cacheEntry, await layer2.GetAsync <int>("Cleanup_CleansAllTheLayers"));

            await cacheStack.CleanupAsync();

            Assert.IsNull(await layer1.GetAsync <int>("Cleanup_CleansAllTheLayers"));
            Assert.IsNull(await layer2.GetAsync <int>("Cleanup_CleansAllTheLayers"));
        }