public async ValueTask MemoryCacheLayer_Indepedent_GetOrSet()
{
var cacheLayer = new MemoryCacheLayer();
//Set first 100 (simple type)
for (var i = 0; i < 100; i++)
{
var result = cacheLayer.GetAsync <int>("Comparison_" + i);
if (result == null)
{
await cacheLayer.SetAsync("Comparison_" + i, new CacheEntry <int>(1, TimeSpan.FromDays(1)));
}
}
//Set last 200 (complex type)
for (var i = 100; i < 200; i++)
{
var result = cacheLayer.GetAsync <int>("Comparison_" + i);
if (result == null)
{
await cacheLayer.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 }
}
}, TimeSpan.FromDays(1)));
}
}
}
public async Task GetOrSet_BackPropagatesToEarlierCacheLayers()
{
var layer1 = new MemoryCacheLayer();
var layer2 = new MemoryCacheLayer();
var layer3 = new MemoryCacheLayer();
var cacheStack = new CacheStack(new[] { layer1, layer2, layer3 }, Array.Empty <ICacheExtension>());
var cacheEntry = new CacheEntry <int>(42, TimeSpan.FromDays(1));
layer2.Set("GetOrSet_BackPropagatesToEarlierCacheLayers", cacheEntry);
var cacheEntryFromStack = await cacheStack.GetOrSetAsync <int>("GetOrSet_BackPropagatesToEarlierCacheLayers", (old) =>
{
return(Task.FromResult(14));
}, new CacheSettings(TimeSpan.FromDays(1), TimeSpan.FromMinutes(1)));
Assert.AreEqual(cacheEntry.Value, cacheEntryFromStack);
//Give enough time for the background task back propagation to happen
await Task.Delay(2000);
Assert.AreEqual(cacheEntry, layer1.Get <int>("GetOrSet_BackPropagatesToEarlierCacheLayers"));
Assert.IsNull(layer3.Get <int>("GetOrSet_BackPropagatesToEarlierCacheLayers"));
await DisposeOf(cacheStack);
}
public async Task Set_SetsAllTheLayers()
{
var layer1 = new MemoryCacheLayer();
var layer2 = new MemoryCacheLayer();
using var cacheStack = new CacheStack(new[] { layer1, layer2 }, Array.Empty <ICacheExtension>());
var cacheEntry = await cacheStack.SetAsync("Set_SetsAllTheLayers", 42, TimeSpan.FromDays(1));
Assert.AreEqual(cacheEntry, await layer1.GetAsync <int>("Set_SetsAllTheLayers"));
Assert.AreEqual(cacheEntry, await layer2.GetAsync <int>("Set_SetsAllTheLayers"));
}
public async ValueTask MemoryCacheLayer_Independent()
{
var cacheLayer = new MemoryCacheLayer();
//Get 100 misses
for (var i = 0; i < 100; i++)
{
await cacheLayer.GetAsync <int>("GetMiss_" + i);
}
var startDate = DateTime.UtcNow.AddDays(-50);
//Set first 100 (simple type)
for (var i = 0; i < 100; i++)
{
await cacheLayer.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 cacheLayer.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 cacheLayer.GetAsync <int>("Comparison_" + i);
}
//Get last 50 (complex type)
for (var i = 150; i < 200; i++)
{
await cacheLayer.GetAsync <RealCostComplexType>("Comparison_" + i);
}
//Evict middle 100
for (var i = 50; i < 150; i++)
{
await cacheLayer.EvictAsync("Comparison_" + i);
}
//Cleanup outer 100
await cacheLayer.CleanupAsync();
}
public async ValueTask CacheTower_MemoryCacheLayer_Direct()
{
var layer = new MemoryCacheLayer();
await LoopActionAsync(Iterations, async() =>
{
await layer.SetAsync("TestKey", new CacheEntry <int>(123, DateTime.UtcNow + TimeSpan.FromDays(1)));
await layer.GetAsync <int>("TestKey");
var getOrSetResult = await layer.GetAsync <string>("GetOrSet_TestKey");
if (getOrSetResult == null)
{
await layer.SetAsync("GetOrSet_TestKey", new CacheEntry <string>("Hello World", TimeSpan.FromDays(1)));
}
});
}
public void CacheTower_MemoryCacheLayer_Direct()
{
var layer = new MemoryCacheLayer();
LoopAction(Iterations, () =>
{
layer.Set("TestKey", new CacheEntry <int>(123, DateTime.UtcNow + TimeSpan.FromDays(1)));
layer.Get <int>("TestKey");
var getOrSetResult = layer.Get <string>("GetOrSet_TestKey");
if (getOrSetResult == null)
{
layer.Set("GetOrSet_TestKey", new CacheEntry <string>("Hello World", TimeSpan.FromDays(1)));
}
});
}
public async Task Evict_EvictsAllTheLayers()
{
var layer1 = new MemoryCacheLayer();
var layer2 = new MemoryCacheLayer();
var cacheStack = new CacheStack(new[] { layer1, layer2 }, Array.Empty <ICacheExtension>());
var cacheEntry = await cacheStack.SetAsync("Evict_EvictsAllTheLayers", 42, TimeSpan.FromDays(1));
Assert.AreEqual(cacheEntry, layer1.Get <int>("Evict_EvictsAllTheLayers"));
Assert.AreEqual(cacheEntry, layer2.Get <int>("Evict_EvictsAllTheLayers"));
await cacheStack.EvictAsync("Evict_EvictsAllTheLayers");
Assert.IsNull(layer1.Get <int>("Evict_EvictsAllTheLayers"));
Assert.IsNull(layer2.Get <int>("Evict_EvictsAllTheLayers"));
await DisposeOf(cacheStack);
}
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"));
}
public async ValueTask MemoryCacheLayer()
{
var cacheLayer = new MemoryCacheLayer();
await BenchmarkWork(cacheLayer);
}
public void MemoryCacheLayer()
{
var cacheLayer = new MemoryCacheLayer();
BenchmarkWork(cacheLayer);
}
