public async Task Flush_FlushesAllTheLayers()
{
var layer1 = new MemoryCacheLayer();
var layer2 = new MemoryCacheLayer();
await using var cacheStack = new CacheStack(new[] { layer1, layer2 }, Array.Empty <ICacheExtension>());
var cacheEntry = await cacheStack.SetAsync("Flush_FlushesAllTheLayers", 42, TimeSpan.FromDays(1));
Assert.AreEqual(cacheEntry, await layer1.GetAsync <int>("Flush_FlushesAllTheLayers"));
Assert.AreEqual(cacheEntry, await layer2.GetAsync <int>("Flush_FlushesAllTheLayers"));
await cacheStack.FlushAsync();
Assert.IsNull(await layer1.GetAsync <int>("Flush_FlushesAllTheLayers"));
Assert.IsNull(await layer2.GetAsync <int>("Flush_FlushesAllTheLayers"));
}
public ListDisplayWidget() {
historyBack = new CacheStack<Uri>(CommonUtil.HistoryNumItems, CommonUtil.HistoryTrimNum);
historyForward = new CacheStack<Uri>(CommonUtil.HistoryNumItems, CommonUtil.HistoryTrimNum);
mainTreeView = new TreeView();
mainTreeView.Selection.Mode = SelectionMode.Multiple;
TreeViewColumn col = new TreeViewColumn();
col.Title = "";
col.Sizing = TreeViewColumnSizing.Autosize;
mainTreeView.AppendColumn(col);
CellRendererPixbuf iconCell = new CellRendererPixbuf();
col.PackStart(iconCell, true);
col.SetCellDataFunc(iconCell, new TreeCellDataFunc(RenderIcon));
col2=col = new TreeViewColumn();
col.Title = "Name";
col.Sizing = TreeViewColumnSizing.Autosize;
mainTreeView.AppendColumn(col);
Gtk.CellRendererText nameCell = new Gtk.CellRendererText();
col.PackStart(nameCell, true);
col.SetCellDataFunc(nameCell, new TreeCellDataFunc(RenderFileName));
nameCell.Edited += fileNameCell_Edited;
rend = nameCell;
col = new TreeViewColumn();
col.Title = "Size";
mainTreeView.AppendColumn(col);
Gtk.CellRendererText sizeCell = new Gtk.CellRendererText();
col.PackStart(sizeCell, true);
col.SetCellDataFunc(sizeCell, new TreeCellDataFunc(RenderFileSize));
col = new TreeViewColumn();
col.Title = "Date";
mainTreeView.AppendColumn(col);
Gtk.CellRendererText dateCell = new Gtk.CellRendererText();
col.PackStart(dateCell, true);
//col.AddAttribute(dateCell, "text", 2);
col.SetCellDataFunc(dateCell, new TreeCellDataFunc(RenderFileDateModified));
listStore = new ListStore(typeof(XeFileInfo));
//mainTreeView.Model = listStore;
TreeModelFilter filter = new TreeModelFilter(listStore, null);
filter.VisibleFunc = new Gtk.TreeModelFilterVisibleFunc(FilterList);
mainTreeView.Model = filter;
mainTreeView.RowActivated += new RowActivatedHandler(OnRowActivated);
Add(mainTreeView);
}
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 ListDisplayControl() : base("Page1") {
HistoryBack = new CacheStack<Uri>(CommonUtil.HistoryNumItems, CommonUtil.HistoryTrimNum);
HistoryForward = new CacheStack<Uri>(CommonUtil.HistoryNumItems, CommonUtil.HistoryTrimNum);
lv = new ListView();
lv.Dock = DockStyle.Fill;
lv.View = View.Details;
lv.AllowColumnReorder = false;
lv.FullRowSelect = true;
lv.MultiSelect = true;
lv.Columns.Add("Name", 200);
lv.Columns.Add("Size", 100);
lv.Columns.Add("Date Modified", 150);
lv.ItemActivate += new EventHandler(OnItemActivated);
this.Controls.Add(lv);
}
public async Task GetOrSet_CacheMiss_ContextFactoryCalledEachTime()
{
var contextValue = 0;
using var cacheStack = new CacheStack <int>(() => contextValue++, new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
var result1 = await cacheStack.GetOrSetAsync <int>("GetOrSet_CacheMiss_ContextFactoryCalledEachTime_1", (oldValue, context) =>
{
Assert.AreEqual(0, context);
return(Task.FromResult(5));
}, new CacheSettings(TimeSpan.FromDays(1)));
Assert.AreEqual(5, result1);
var result2 = await cacheStack.GetOrSetAsync <int>("GetOrSet_CacheMiss_ContextFactoryCalledEachTime_2", (oldValue, context) =>
{
Assert.AreEqual(1, context);
return(Task.FromResult(5));
}, new CacheSettings(TimeSpan.FromDays(1)));
Assert.AreEqual(5, result2);
}
public async Task GetOrSet_BackPropagatesToEarlierCacheLayers()
{
var layer1 = new MemoryCacheLayer();
var layer2 = new MemoryCacheLayer();
var layer3 = new MemoryCacheLayer();
await using var cacheStack = new CacheStack(new[] { layer1, layer2, layer3 }, Array.Empty <ICacheExtension>());
var cacheEntry = new CacheEntry <int>(42, TimeSpan.FromDays(1));
await layer2.SetAsync("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, await layer1.GetAsync <int>("GetOrSet_BackPropagatesToEarlierCacheLayers"));
Assert.IsNull(await layer3.GetAsync <int>("GetOrSet_BackPropagatesToEarlierCacheLayers"));
}
public async Task GetOrSet_FourSimultaneous()
{
await using (var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>()))
{
await cacheStack.SetAsync("GetOrSet", new CacheEntry <int>(15, DateTime.UtcNow.AddDays(-1)));
for (var i = 0; i < WorkIterations; i++)
{
var task1 = cacheStack.GetOrSetAsync <int>("GetOrSet", async(old) =>
{
await Task.Delay(30);
return(12);
}, new CacheSettings(TimeSpan.FromDays(1)));
var task2 = cacheStack.GetOrSetAsync <int>("GetOrSet", async(old) =>
{
await Task.Delay(30);
return(12);
}, new CacheSettings(TimeSpan.FromDays(1)));
var task3 = cacheStack.GetOrSetAsync <int>("GetOrSet", async(old) =>
{
await Task.Delay(30);
return(12);
}, new CacheSettings(TimeSpan.FromDays(1)));
var task4 = cacheStack.GetOrSetAsync <int>("GetOrSet", async(old) =>
{
await Task.Delay(30);
return(12);
}, new CacheSettings(TimeSpan.FromDays(1)));
await task1;
await task2;
await task3;
await task4;
}
}
}
public CacheAlternatives_Redis_Benchmark()
{
CacheTower = new CacheStack(new[] { new RedisCacheLayer(RedisHelper.GetConnection()) }, Array.Empty <ICacheExtension>());
CacheManager = CacheFactory.Build <ProtobufCacheItem>(b =>
{
b.WithRedisConfiguration("redisLocal", "localhost:6379,ssl=false");
b.WithRedisCacheHandle("redisLocal", true);
b.WithProtoBufSerializer();
});
var easyCachingRedisOptions = new RedisOptions
{
DBConfig = new RedisDBOptions
{
Configuration = "localhost:6379,ssl=false"
}
};
EasyCaching = new DefaultRedisCachingProvider("EasyCaching",
new[] { new RedisDatabaseProvider("EasyCaching", easyCachingRedisOptions) },
new[] { new DefaultProtobufSerializer("EasyCaching") },
easyCachingRedisOptions
);
}
public async Task GetOrSet_CacheHitBackgroundRefresh()
{
await using var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
var cacheEntry = new CacheEntry <int>(17, DateTime.UtcNow.AddDays(1));
await cacheStack.SetAsync("GetOrSet_CacheHitBackgroundRefresh", cacheEntry);
var waitingOnBackgroundTask = new TaskCompletionSource <int>();
var result = await cacheStack.GetOrSetAsync <int>("GetOrSet_CacheHitBackgroundRefresh", (oldValue) =>
{
waitingOnBackgroundTask.TrySetResult(27);
return(Task.FromResult(27));
}, new CacheSettings(TimeSpan.FromDays(2), TimeSpan.Zero));
Assert.AreEqual(17, result);
await waitingOnBackgroundTask.Task;
//Give 400ms to return the value and set it to the MemoryCacheLayer
await Task.Delay(400);
var refetchedResult = await cacheStack.GetAsync <int>("GetOrSet_CacheHitBackgroundRefresh");
Assert.AreEqual(27, refetchedResult.Value);
}
public async Task GetOrSet_ConcurrentStaleCacheHits()
{
var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
var cacheEntry = new CacheEntry <int>(23, DateTime.UtcNow.AddDays(-2));
await cacheStack.SetAsync("GetOrSet_ConcurrentStaleCacheHits", cacheEntry);
var request1LockSource = new TaskCompletionSource <bool>();
var request2StartLockSource = new TaskCompletionSource <bool>();
//Request 1 gets the lock on the refresh and ends up being tied up due to the TaskCompletionSource
var request1Task = cacheStack.GetOrSetAsync <int>("GetOrSet_ConcurrentStaleCacheHits", async(oldValue) =>
{
request2StartLockSource.SetResult(true);
await request1LockSource.Task;
return(99);
}, new CacheSettings(TimeSpan.FromDays(2), TimeSpan.Zero));
await request2StartLockSource.Task;
//Request 2 sees there is a lock already and because we still at least have old data, rather than wait
//it is given the old cache data even though we are past the point where even stale data should be removed
var request2Result = await cacheStack.GetOrSetAsync <int>("GetOrSet_ConcurrentStaleCacheHits", (oldValue) =>
{
return(Task.FromResult(99));
}, new CacheSettings(TimeSpan.FromDays(2), TimeSpan.Zero));
//Unlock Request 1 to to continue
request1LockSource.SetResult(true);
//Wait for Request 1 to complete so we get the new data
var request1Result = await request1Task;
Assert.AreEqual(99, request1Result);
Assert.AreEqual(23, request2Result);
await DisposeOf(cacheStack);
}
public async Task Evict_ThrowsOnNullKey()
{
var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
await cacheStack.EvictAsync(null);
}
public async Task ConstructorAllowsNullExtensions()
{
var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, null);
await DisposeOf(cacheStack);
}
public async Task GetOrSet_ThrowsOnNullGetter()
{
var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
await cacheStack.GetOrSetAsync <int>("MyCacheKey", null, new CacheSettings(TimeSpan.FromDays(1)));
}
public async Task GetOrSet_ThrowsOnNullKey()
{
var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
await cacheStack.GetOrSetAsync <int>(null, (old) => Task.FromResult(5), new CacheSettings(TimeSpan.FromDays(1)));
}
public async Task Set_ThrowsOnNullCacheEntry()
{
var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
await cacheStack.SetAsync("MyCacheKey", (CacheEntry <int>) null);
}
public async Task Set_ThrowsOnNullKey()
{
var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
await cacheStack.SetAsync(null, new CacheEntry <int>(1, TimeSpan.FromDays(1)));
}
public override void Free(T obj)
{
_resetMethod.InvokeGracefully(obj);
CacheStack.Push(obj);
}
public CacheAlternatives_File_Benchmark()
{
CacheTowerJson = new CacheStack(new[] { new JsonFileCacheLayer(DirectoryPath) }, Array.Empty <ICacheExtension>());
CacheTowerProtobuf = new CacheStack(new[] { new ProtobufFileCacheLayer(DirectoryPath) }, Array.Empty <ICacheExtension>());
}
public void ConstructorAllowsNullExtensions()
{
using var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, null);
}
public SettingStack(T newPush)
{
CacheStack.Push(newPush);
}
public async Task ConstructorAllowsNullExtensions()
{
await using var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, null);
}
public override void Free(T obj)
{
obj.Hide();
_onHideMethod?.Invoke(obj);
CacheStack.Push(obj);
}
public override void Free(T obj)
{
_resetMethod?.Invoke(obj);
CacheStack.Push(obj);
}
public async Task Get_ThrowsOnNullKey()
{
using var cacheStack = new CacheStack(new[] { new MemoryCacheLayer() }, Array.Empty <ICacheExtension>());
await cacheStack.GetAsync <int>(null);
}
