Innovabit.DotNet.Interceptors.Caching.Abstractions 1.0.0.96

Innovabit.DotNet.Interceptors.Caching.Abstractions

Method-result caching for Innovabit.DotNet.Interceptors via a [Cache] attribute. This is the provider-agnostic base: it ships the interceptor, the attribute, the pluggable key generator/serializer and the ICacheStore abstraction. Pick a store provider to actually cache anything:

• Innovabit.DotNet.Interceptors.Caching.Memory — in-process cache on .NET's IMemoryCache.
• Innovabit.DotNet.Interceptors.Caching.Redis — distributed cache on Redis (IDistributedCache).

Usage

services
    .AddInterceptors()
    .AddInMemoryCache()                       // or .AddRedisCache(o => o.Configuration = "localhost:6379")
    .ConfigureCacheDefaults(d => d.DurationSeconds = 60);   // optional global defaults

services.AddScopedWithInterception<IPriceService, PriceService>();

public class PriceService : IPriceService
{
    // Cached for 30s; a bare [Cache] would inherit the configured defaults.
    [Cache(DurationSeconds = 30)]
    public Task<decimal> GetQuoteAsync(string symbol) => _api.FetchAsync(symbol);
}

The first call runs the method and stores the result; later calls with the same arguments return the cached value without invoking the method. Only value-returning methods are cached — void, Task and ValueTask (no result) are ignored; Task<T>/ValueTask<T> are cached on their unwrapped result.

[Cache] / CacheDefaults

Any property left unset on [Cache] inherits from the CacheDefaults configured via ConfigureCacheDefaults; a property set on the method always wins.

Cache keys

The key is derived per method + argument values, so calls with different arguments are cached separately and calls with the same arguments share an entry. The default ICacheKeyGenerator hashes the method signature and the JSON-serialized arguments (SHA-256).

Two kinds of parameter are left out of the key:

• CancellationToken parameters — always ignored (runtime plumbing, not part of a call's identity).
• Parameters marked [CacheKeyIgnore] — opt a specific parameter out of the key when it does not affect the result (a logger, a correlation id, an IProgress<T> callback, …).

// requestId does not change the result, so both calls hit the same cache entry:
[Cache(DurationSeconds = 30)]
public Task<Quote> GetQuoteAsync(string symbol, [CacheKeyIgnore] Guid requestId) => _api.FetchAsync(symbol);

[CacheKeyIgnore] is honoured by the default key generator; a custom generator defines its own policy. Like other parameter-level attributes it only has an effect while the method is intercepted (also carries [Cache]) — the bundled analyzer warns (INTX002) when it does not.

Flexibility / extension points

Everything is resolved from DI and can be swapped:

• ICacheStore — the backing store. Provided by the Memory/Redis packages; implement your own for any backend.
• ICacheKeyGenerator — how keys are derived. Default: SHA-256 over the method signature + JSON-serialized arguments (ignoring CancellationToken and [CacheKeyIgnore] parameters). Replace with UseCacheKeyGenerator<T>().
• ICacheSerializer — how values are serialized for distributed stores. Default: System.Text.Json. Replace with UseCacheSerializer<T>().

Pipeline order

CacheInterceptor runs at InterceptorOrders.Caching (200) — above retry/timeout so a hit short-circuits the expensive work, below validation so invalid arguments still fail fast. Override per registration with .Register<CacheInterceptor>(order) / .SetOrder<CacheInterceptor>(order).