A tiny and efficient drop-in replacement for MediatR's most common usage pattern.

VibedMediatr is a minimal implementation of the Mediator pattern that focuses exclusively on the core request/handler pattern used by most MediatR applications. It's designed to be a drop-in replacement for apps that only need:

• IRequest<TResponse> and IRequest interfaces
• IRequestHandler<TRequest, TResponse> and IRequestHandler<TRequest> interfaces
• IMediator.Send(...) method

Everything else is intentionally out of scope. This keeps the codebase small, focused, and easy to understand.

✅ Drop-in replacement - Uses the same MediatR namespace and contracts
✅ Minimal surface area - Only 3 interfaces and 1 extension method
✅ High performance - Cached delegates avoid repeated reflection
✅ Secure by default - Opt-in assembly scanning only
✅ Scoped mediator - Avoids capturing the root service provider
✅ Full async support - Cancellation tokens throughout

dotnet add package VibedMediatr

using MediatR;

public sealed record Ping(string Message) : IRequest<string>;

using MediatR;

public sealed class PingHandler : IRequestHandler<Ping, string>
{
    public Task<string> Handle(Ping request, CancellationToken cancellationToken)
        => Task.FromResult($"Pong: {request.Message}");
}

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
// Scan entry assembly + any additional assemblies
builder.Services.AddVibedMediatr(typeof(Program).Assembly);

var app = builder.Build();

public class IndexModel(IMediator mediator) : PageModel
{
    public string? Reply { get; private set; }

    public async Task OnGet()
    {
        Reply = await mediator.Send(new Ping("Hello World!"));
    }
}

namespace MediatR
{
    public interface IRequest<out TResponse> { }
    public interface IRequest { }

    public interface IRequestHandler<in TRequest, TResponse>
        where TRequest : IRequest<TResponse>
    {
        Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken);
    }

    public interface IRequestHandler<in TRequest>
        where TRequest : IRequest
    {
        Task Handle(TRequest request, CancellationToken cancellationToken);
    }

    public interface IMediator
    {
        Task<TResponse> Send<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default);
        Task Send(IRequest request, CancellationToken cancellationToken = default);
    }
}

namespace VibedMediatr
{
    public static class ServiceCollectionExtensions
    {
        // Scan only entry assembly
        public static IServiceCollection AddVibedMediatr(this IServiceCollection services);

        // Scan entry assembly + additional assemblies
        public static IServiceCollection AddVibedMediatr(this IServiceCollection services, params Assembly[] additionalAssemblies);
    }
}

VibedMediatr uses a two-phase approach for optimal performance:

1. Cold path (first request of each type): Reflection is used to build a compiled delegate
2. Hot path (subsequent requests): The cached delegate is invoked directly

This ensures minimal overhead after the initial setup while maintaining type safety and avoiding code generation.

• Opt-in assembly scanning: Only explicitly provided assemblies are scanned
• No dynamic code generation: Uses MakeGenericMethod instead of ILGenerator
• Scoped service provider: Prevents capturing the root container
• Type filtering: Only concrete, non-abstract handler classes are registered

VibedMediatr provides clear error messages for common issues:

• No handler found: InvalidOperationException with details about the missing handler
• Invalid request type: InvalidOperationException when request doesn't implement required interfaces
• Null requests: ArgumentNullException for null request parameters

See the VibedMediatr.Example project for a complete Razor Pages demonstration.

Contributions are welcome! Please submit a pull request.

MIT License - see LICENSE file for details.