static void Main(string[] args)
{
//Config
{
//var options = new JsonConfigurationHelper().Get<CacheOptions>("Cache", "", true);
//if (options == null)
// Console.WriteLine("配置文件错误");
}
//MemeoryCache
{
IMemoryCache memory = new MemoryCache(Options.Create(new MemoryCacheOptions()));
ICacheHandler MemoryCahce = new MemoryCacheHandler(memory);
MemoryCahce.Set("a", "测试内存缓存");
MemoryCahce.Get("a");
Console.WriteLine(MemoryCahce.Get("a"));
}
//RedisCache
{
var Redis = new RedisCacheHelper();
ICacheHandler RedisCache = new RedisCacheHandler(Redis);
RedisCache.Set("b", "测试Redis缓存");
RedisCache.Get("b");
Console.WriteLine(RedisCache.Get("b"));
}
}
public void Creates_Instance_WithOptions_Argument()
{
// Arrange, Act
var result = MemoryCacheHandler.New(new Mock <IMemoryCache>().Object, new MemoryCacheEntryOptions());
// Assert
Assert.NotNull(result);
}
public void Creates_Instance()
{
// Arrange, Act
var result = MemoryCacheHandler.New(new Mock <IMemoryCache>().Object);
// Assert
Assert.NotNull(result);
}
internal override Action <IServiceCollection> GetBuild()
{
return(services =>
{
services.AddMemoryCache();
services.AddSingleton(provider => MemoryCacheHandler.New(provider.GetService <IMemoryCache>(), Options));
Descriptors.ForEach(services.TryAdd);
});
}
public async Task Instance_Created_Through_MemoryCacher_New_Runs_With_Provided_Cache()
{
// Arrange
var cacher = MemoryCacheHandler.New(_memoryCache);
// Act
var result = await cacher.GetOrFetchAsync("name", _ => Task.FromResult("sven"));
// Assert
Assert.Equal("sven", result);
Assert.Equal("sven", _memoryCache.Get <string>("name"));
}
public async void Construct_WhenGivenValidConfiguration_ShouldApplyConfiguration()
{
var ch = new MemoryCacheHandler(new MemoryCacheHandlerConfiguration("0 0 0/1 1/1 * ? *"));
Assert.AreEqual(typeof(MemoryCacheHandler), ch.Configuration.Type);
Assert.AreEqual("0 0 0/1 1/1 * ? *", ch.Configuration.ExpireTime);
var key = ch.CreateKey("whale", "fail");
var d = new ReportItem()
{
Key = "grumpy"
};
await ch.AddOrUpdate(key, d);
var r = await ch.GetValue <ReportItem>(key);
Assert.AreEqual(d.Key, r.Key);
}
public SimpleCacheLoad()
{
_cache = new MemoryCache(new MemoryCacheOptions());
_cacher = MemoryCacheHandler.New(_cache);
var services = new ServiceCollection();
services.AddCached(config =>
{
config.AddMemoryCaching(options =>
{
options.AddFunction <string, string>(
arg => arg,
(provider, key, arg) => Task.FromResult(DateTimeOffset.UtcNow.ToString()));
});
});
_serviceProvider = services.BuildServiceProvider();
_cached = _serviceProvider.GetService <ICached <string, string> >();
}
private static async Task Main(string[] args)
{
using var cache = MemoryCacheHandler.New();
while (true)
{
Console.WriteLine("Press any key, used as cache key, to get data from cache (or 'q' to quit)");
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key == ConsoleKey.Q)
{
break;
}
var result = await cache.GetOrFetchAsync(
key.Key.ToString(),
provider => Task.FromResult(DateTimeOffset.UtcNow.ToString()));
Console.WriteLine($"Value is: {result}");
}
}
public void If_MemoryCache_Argument_Is_Null()
{
Assert.Throws <ArgumentNullException>(() =>
MemoryCacheHandler.New(null, new MemoryCacheEntryOptions()));
}
