ExpressionCache.Core 6.1.0

ExpressionCache.Core

Cache keys from .NET method call expressions, and the base classes for ExpressionCache providers. This package turns a method call expression into a key (type name, method name and argument values), and returns the cached result or calls the method and caches what it returns. The cache itself comes from a provider.

// Cache key: ExprCache{ProductService}{GetAsync}{42}{Bypass}
string key = cache.GetKey(() => GetAsync(42, CacheAction.Bypass));

To cache in IDistributedCache (Redis, SQL Server, in-memory and others), install ExpressionCache.Distributed instead. It includes this package and has a getting started guide.

Full documentation: github.com/Baune8D/ExpressionCache

Contents

Cache keys

A key is ExprCache followed by one {...} part for each of these:

1. The type of the object the method is called on, without its namespace. This is the type of the expression in your code: this gives the class, a variable declared as an interface gives the interface. A static method has no object, so this part is {0x6e756c6c}.
2. The method name.
3. For a generic method, each type argument, with its namespace: Find<Product>() adds {MyApp.Product}.
4. Each argument value, in order.

Argument values are converted as follows. The checks run in this order:

Implement ICacheKey to use your own type as an argument. BuildCacheKey adds the values that identify an instance, converted as in the table above:

using ExpressionCache.Core;

public sealed class ProductQuery : ICacheKey
{
    public string? Category { get; init; }

    public int Page { get; init; }

    public void BuildCacheKey(ICacheKeyBuilder builder)
    {
        builder
            .By(Category)
            .By(Page);
    }
}

In ProductService, () => SearchAsync(new ProductQuery { Category = "books", Page = 2 }, CacheAction.Bypass) gets the key ExprCache{ProductService}{SearchAsync}{books}{2}{Bypass}.

A key contains only these parts, so some calls share a key, e.g. overloads called with the same values. See Keys that can collide.

Writing a provider

To use a cache, implement IExpressionCacheProvider and derive from ExpressionCacheBase. For example, for IMemoryCache:

using ExpressionCache.Core;
using Microsoft.Extensions.Caching.Memory;

public sealed class MemoryCacheProvider(IMemoryCache cache) : IExpressionCacheProvider
{
    public CacheResult<TResult> Get<TResult>(string key)
    {
        return cache.TryGetValue(key, out TResult? value)
            ? new CacheResult<TResult> { Success = true, Content = value }
            : CacheResult<TResult>.Failure();
    }

    public Task<CacheResult<TResult>> GetAsync<TResult>(string key)
    {
        return Task.FromResult(Get<TResult>(key));
    }

    public void Set<TResult>(string key, TResult value, TimeSpan expiry)
    {
        cache.Set(key, value, expiry);
    }

    public Task SetAsync<TResult>(string key, TResult value, TimeSpan expiry)
    {
        Set(key, value, expiry);
        return Task.CompletedTask;
    }
}

public sealed class MemoryExpressionCache(IMemoryCache cache)
    : ExpressionCacheBase(new MemoryCacheProvider(cache));

Register it as a singleton and inject IExpressionCacheBase:

builder.Services.AddMemoryCache();
builder.Services.AddSingleton<IExpressionCacheBase, MemoryExpressionCache>();

• Return CacheResult<TResult>.Failure() on a miss, or Success = true with the value in Content.
• ExpressionCacheBase only calls Set and SetAsync with non-null values.
• Subclasses get the provider from the protected Provider property.
• ExpressionCacheBase is IDisposable. It keeps the type and method part of each key in an IMemoryCache, which it disposes when it is disposed. The constructor that takes only a provider creates that cache. The other constructor takes it as its first argument, so don't pass a cache you use for anything else.

ExpressionCache.Distributed is built the same way: see DistributedCacheProvider and DistributedCacheService.

Limitations

• The lambda must be a single method call, such as () => GetAsync(id, CacheAction.Bypass). Anything else, such as () => GetName() ?? "none", throws ArgumentException. The arguments can be any expression.

License

MIT