public static void SetToWithDefault <TItem, TRhs, TKey>(
this ICache <TItem, TKey> not,
IReadOnlyCache <TRhs, TKey> rhs,
IReadOnlyCache <TRhs, TKey>?def,
Func <TRhs, TRhs?, TItem> converter)
where TRhs : class
{
if (def == null)
{
not.SetTo(
rhs.Items.Select((t) => converter(t, default)));
}
else
{
not.SetTo(
rhs.Select((t) =>
{
TRhs?defVal;
if (def.TryGetValue(t.Key, out var get))
{
defVal = get;
}
else
{
defVal = default;
}
return(converter(t.Value, defVal));
}));
}
}
public async Task OneTimeSetUp()
{
_cache = await new ReadOnlyCacheBuilder <IPAddress, LatLon>("ip-lat-lng", new IpApiDataSource())
.WithLocalCache(new MemoryCache <IPAddress, LatLon>())
.WithLoggerFactory(new ConsoleLoggerFactory())
.BuildAsync();
}
public async Task OneTimeSetUp()
{
_cache = await new ReadOnlyCacheBuilder <TemplateData, string>("templates", new TemplateDataSource())
.WithLocalCache(new MemoryCache <TemplateData, string>())
.WithLoggerFactory(new ConsoleLoggerFactory())
.BuildAsync();
}
public static void RemapLinks <TMajorGetter>(this IReadOnlyCache <TMajorGetter, FormKey> cache, IReadOnlyDictionary <FormKey, FormKey> mapping)
where TMajorGetter : class, IMajorRecordCommonGetter, IFormLinkContainer
{
foreach (var item in cache.Items)
{
item.RemapLinks(mapping);
}
}
public InMemoryCacheIndex(IReadOnlyCache <TKey, TValue> cache, ICache <TIndex, TValue> index,
Func <TValue, TIndex> keyProvider)
{
_index = index;
_keyProvider = keyProvider;
_cache = cache;
_added = _cache.Subscribe((IObserver <CacheItemAdded <TValue> >) this);
_removed = _cache.Subscribe((IObserver <CacheItemRemoved <TValue> >) this);
_updated = _cache.Subscribe((IObserver <CacheItemUpdated <TValue> >) this);
}
public LocalGetBenchmark()
{
_concurrentDictionary = CreateConcurrentDictionary();
_modernCache = CreateModernCache();
_cacheTower = CreateCacheTower();
_foundatio = CreateFoundatio();
_lazyCache = CreateLazyCache();
_fusionCache = CreateFusionCache();
_easyCache = CreateEasyCache();
_cacheManager = CreateCacheManager();
}
public static bool TryGetValue <TObject, TKey>(this IReadOnlyCache <TObject, TKey> cache, TKey key, [MaybeNullWhen(false)] out TObject value)
{
// ToDo
// Improve to not double query
if (cache.ContainsKey(key))
{
value = cache[key];
return(true);
}
value = default;
return(false);
}
public async Task OneTimeSetUp()
{
_docker = new DockerClientConfiguration().CreateClient();
_containerIds = await Task.WhenAll(
RunContainerAsync(_docker, "redis", 6379),
RunContainerAsync(_docker, "postgres", 5432, new[] { "POSTGRES_HOST_AUTH_METHOD=trust" })
);
var redis = await ConnectionMultiplexer.ConnectAsync("localhost,allowAdmin=true");
string postgreSqlConnectionString = "Host=localhost;User ID=postgres";
await InitializePostgreSql(postgreSqlConnectionString);
_cache = await new ReadOnlyCacheBuilder <Guid, User>("test", new UserDataSource(postgreSqlConnectionString))
.WithLocalCache(new MemoryCache <Guid, User>())
.WithDistributedCache(new RedisAsyncCache(redis), new ProtobufKeyValueSerializer <Guid, User>())
.WithLoggerFactory(new ConsoleLoggerFactory())
.WithPreload(_ => Task.FromResult <IEnumerable <Guid> >(new Guid[] { new("c11f0067-ec91-4355-8c7e-1caf4c940136") }), null)
public static IEnumerable <KeyValuePair <K, R> > SelectAgainst <K, V, R>(
this IReadOnlyCache <V, K> lhs,
IReadOnlyCache <V, K> rhs,
Func <K, V, V, R> selector,
out bool equal)
{
var ret = new List <KeyValuePair <K, R> >();
equal = lhs.Count == rhs.Count;
foreach (var item in lhs)
{
if (!rhs.ContainsKey(item.Key))
{
equal = false;
continue;
}
ret.Add(
new KeyValuePair <K, R>(
item.Key,
selector(item.Key, item.Value, rhs[item.Key])));
}
return(ret);
}
public ReadOnlyValue(IReadOnlyCache <int, T> cache)
{
_cache = cache;
}
public void MyTestInitialize()
{
_mockCacheable = new Mock <ICacheable <int, ITestObject> >();
_cache = new ReadOnlyPicnicCache <int, ITestObject>(x => x.Id, _mockCacheable.Object);
}