ModernCaching 0.0.2

ModernCaching

A 2-layer, performant and resilient caching solution for modern .NET.

A typical cache provided by this library consists of:

• a synchronous local cache that implements ICache
• an asynchronous distributed cache that implements IAsyncCache (e.g. memcache, redis)
• a data source that implements IDataSource (e.g. relational database, Web API, CPU intensive task...)

These 3 components form an IReadOnlyCache. The 2 cache layers are populated from the IDataSource with a backfilling mechanism when getting a value or by preloading some data when building the cache.

ModernCaching doesn't provide implementations of IAsyncCache or IDataSource because they are usually tied to the business. Only a single implementation of ICache is built-in: MemoryCache.

This library is inspired by a component of the Criteo's SDK that handles 10B+ requests per second (hint: it's a lot). ModernCaching is production ready but lacks a way to invalidate data (#1).

Installation

ModernCaching is available on Nuget.

dotnet add package ModernCaching

Features

• Strict API. IReadOnlyCache has only two methods:
  • TryPeek, a synchronous operation to only get the value if it's present in the local cache and refresh in the background if needed.
  • TryGetAsync, an asynchronous operation to get the first fresh value in the local cache, distributed cache or the data source, in that order.
• Performance. Unlike other caching libraries that use a string as a key or an object as value or both, ModernCaching uses a generic key and value. That way, getting a value from the local cache doesn't require any allocation for simple type keys such as int or more complex user-defined objects. See the benchmarks.
• Resilience. With its fixed number of layers, each behavior is clearly defined when one of these layers is down. For instance, the data source is skipped if the distributed cache is unavailable to avoid DDOSing it.
• Instrumentation. Metrics are exposed using OpenTelemetry API. Errors from user-code are logged if a logger is specified.

Example

This example caches the user information. The first layer is implemented with an in-memory cache, the second one is a redis where we specify how to create the key and how to serialize the value using the interface IKeyValueSerializer. Behind these two layers stands the IDataSource.

var cache = await new ReadOnlyCacheBuilder<Guid, User>("user-cache", new UserDataSource("Host=localhost;User ID=postgres"))
    .WithLocalCache(new MemoryCache<Guid, User>())
    .WithDistributedCache(new RedisAsyncCache(redis), new ProtobufKeyValueSerializer<Guid, User>())
    .BuildAsync();

Guid userId = new("cb22ff11-4683-4ec3-b212-7f1d0ab378cc");
bool found = cache.TryPeek(userId, out User? user); // Only check local cache with background refresh.
(bool found, User? user) = await cache.TryGetAsync(userId); // Check all layers for a fresh value.

The rest of the code as well as other examples can be found in src/ModernCaching.ITest.

Benchmarks

Benchmark of the very hot path of different caching libraries (CacheTower, Foundatio, LazyCache, FusionCache, EasyCaching, CacheManager), that is, getting locally cached data. The .NET ConcurrentDictionary was also added as a baseline.

This library has similar performance as a raw ConcurrentDictionary since its hot path is a thin layer around it. It doesn't allocate anything, putting no pressure on the garbage collector.

Code can be found in src/ModernCaching.Benchmarks.

Instrumentation

Metrics

Metrics are exposed using .NET implementation of the OpenTelemetry Metrics API (System.Diagnostics.Metrics) under the source name ModernCaching. They can be exported using the OpenTelemetry .NET SDK.

Logs

Use WithLoggerFactory on the builder to log all user-code errors coming from IAsyncCache, IKeyValueSerializer or IDataSource.

License

All code found in this repository is licensed under MIT. See the LICENSE file in the project root for the full license text.