New Now available on NuGet

Send a command.
Everything else runs around it.

Name: MediCore
Author: Varun Kumar A

MediCore is a lightweight CQRS mediator for .NET. Validation, logging and transactions run as interceptors, so your handlers only contain business logic.

$dotnet add package MediCore

See how it works Read the docs

mediator.Send(command)

Invalid request? Stops at validationHandler throws? Transaction rolls back

The plumbing you keep rewriting, built in

MediCore gives you the mediator pattern and the cross-cutting pieces that usually come with it.

Request interceptors

Wrap every request with reusable steps. Turn on logging, validation and transactions once, and every command and query gets them.

LoggingValidationTransactions

Notifications

Publish an event once and let any number of handlers react to it.

Service registry

Small, focused interfaces

Commands, queries, notifications and interceptors each have their own interface. Your code says what it does, and swapping or testing a piece stays simple.

Modern .NET

Built for .NET 8 with nullable reference types and XML docs, so IntelliSense explains each type as you type.

Light to adopt

It only depends on the Microsoft.Extensions abstractions for dependency injection and logging. No extra frameworks to pull in.

Running in three steps

Program.cs

using MediCore;

var builder = WebApplication.CreateBuilder(args);

// Scan this assembly for handlers and interceptors
builder.Services.AddMediCore(options =>
{
    options.RegisterHandlersFromAssemblyContaining<Program>();
    options.AddDefaultInterceptors();
    options.UseTransactionManager<MyEfTransactionManager>(); // optional — defaults to TransactionScopeManager
});

var app = builder.Build();
app.Run();

public record CreateOrderCommand(string Customer) : ICommand<int>;

public class CreateOrderHandler : ICommandHandler<CreateOrderCommand, int>
{
    public Task<int> Handle(CreateOrderCommand command, CancellationToken ct)
    {
        // Only business logic here.
        return Task.FromResult(42);
    }
}

// In a controller or endpoint
var orderId = await mediator.Send(new CreateOrderCommand("Varun"));

public class TimingInterceptor<TRequest, TResponse>
    : IRequestInterceptor<TRequest, TResponse>
{
    public async Task<TResponse> Intercept(
        TRequest request, RequestDelegate<TResponse> next, CancellationToken ct)
    {
        var started = Stopwatch.GetTimestamp();

        var response = await next();   // runs the next step, then the handler

        Console.WriteLine($"{typeof(TRequest).Name} took {Stopwatch.GetElapsedTime(started).TotalMilliseconds} ms");
        return response;
    }
}

Built in the open

MediCore is open source and created by Varun Kumar A, a software engineer working with .NET and Angular. Questions, ideas and feedback are always welcome.

Connect on LinkedIn Open an issue

Try MediCore in your next project

Install it, send your first command, and tell us what you think. Feedback and issues on GitHub are very welcome.