MitMediator.InMemoryCache 9.0.0-alfa-2

MitMediator.InMemoryCache

An attribute-driven in-memory caching extension for the MitMediator

Installation

1. Add package

 dotnet add package MitMediator.InMemoryCache -v 9.0.0-alfa-2

2. Register services

// Register handlers and IMediator
builder.Services.AddMitMediator(); 

// Register MemoryCache, InMemoryCacheBehavior,
// scan information about all IRequest<>
builder.Services.AddRequestsInMemoryCache()

⚠️ Important: Make sure .AddRequestsInMemoryCache() is registered as the last IPipelineBehavior. Cached responses will short-circuit the pipeline and prevent further execution

To customize MemoryCache options and specify assemblies to scan:

builder.Services.AddRequestsInMemoryCache(
    new MemoryCacheOptions { SizeLimit = 1000 }, 
    new []{typeof(GetQuery).Assembly});`

Usage

Decorate your request classes with attribute [CacheResponse]

Requests decorated with the [CacheResponse] attribute will have their responses cached in memory. You can control expiration, entry size, and define which requests should invalidate the cache

CacheResponseAttribute params

Use IMediator extension methods to clear cached responses:

Clear cache for specific request data:

mediator.ClearResponseCacheAsync(request, ct);

Clear all cached responses for a request type

mediator.ClearAllResponseCacheAsync<GetBookQuery>(ct);

Example usage

Cache indefinitely:

[CacheResponse]
public struct GetGenresQuery : IRequest<Genre[]>;

Default entrySize is 1

Cache for 10 seconds:

[CacheResponse(10)]
public struct GetBookQuery : IRequest<Book>
{
    public int BookId { get; set; }
}

Invalidate cache on specific requests:

[CacheResponse(typeof(DeleteAuthorCommand), typeof(UpdateAuthorCommand))]
public struct GetAuthorsByFilterQuery : IRequest<Author[]>
{
    public int? Limit { get; init; }
    
    public int? Offset { get; init; }
    
    public string? FreeText { get; init; }
}

Set custom entry size and time (30s)

[CacheResponse(30, 4)]
public struct GetBooksByFilterQuery : IRequest<Book[]>
{
    public int? Limit { get; init; }
    
    public int? Offset { get; init; }
    
    public string? FreeText { get; init; }
}

For ICollection types, the cache entry size is response.Count * entrySize

Clear cache after updating data:

public async ValueTask<Book> HandleAsync(UpdateBookTitleCommand command, CancellationToken cancellationToken)
{
    var book = await _booksRepository.FirstOrDefaultAsync(b => b.BookId == command.BookId, cancellationToken);
        
    book.SetTitle(command.Title);

    await _booksRepository.UpdateAsync(book, cancellationToken);
    
    // Clear cached response for the updated book
    await _mediator.ClearResponseCacheAsync(new GetBookQuery() { BookId = command.BookId }, cancellationToken);
    return book;
}

Responses are cached per unique request data. For example, GetBookQuery caches a separate response for each BookId

See samples

License

MIT