ZeroAlloc.Mediator 4.1.4

ZeroAlloc.Mediator

ZeroAlloc.Mediator is a source-generated, zero-allocation mediator for .NET 8 and .NET 10. It supports request/response, notifications, and streaming without reflection or dynamic dispatch. The source generator eliminates the runtime overhead that reflection-based mediators incur by wiring all dispatch at compile time — no dictionaries, no virtual dispatch, no delegate allocation per request.

Install

dotnet add package ZeroAlloc.Mediator

The generator package must also be added as an analyzer:

<PackageReference Include="ZeroAlloc.Mediator.Generator" Version="*" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />

Example

// 1. Define a request record and its expected response type
public readonly record struct CreateOrder(string Product, int Qty) : IRequest<OrderId>;

// 2. Implement a handler — no constructor dependencies needed for this example
public class CreateOrderHandler : IRequestHandler<CreateOrder, OrderId>
{
    public ValueTask<OrderId> Handle(CreateOrder request, CancellationToken ct)
        => ValueTask.FromResult(OrderId.NewId());
}

// 3. Register IMediator with DI (the generator emits services.AddMediator() automatically)
services.AddMediator();

// 4. Send the request and use the result — fully strongly-typed, zero allocation
public class OrderController(IMediator mediator)
{
    public async Task<IResult> PlaceOrder(CreateOrder cmd, CancellationToken ct)
    {
        var id = await mediator.Send(cmd, ct);   // returns OrderId, no boxing
        return Results.Created($"/orders/{id}", id);
    }
}

Performance

ZeroAlloc.Mediator is 40–160x faster than MediatR with zero heap allocation on all non-streaming paths (.NET 10.0.4, i9-12900HK, BenchmarkDotNet).

The 104 B on the Stream row is the C# compiler's async IAsyncEnumerable<T> state machine for your handler method — every mediator dispatching to such handlers pays this; ZA.Mediator's own stream-dispatch contribution is 0 B. See docs/performance.md for the full benchmark table and zero-allocation design explanation.

Features

• Request/Response — strongly-typed Send overloads per request type
• Notifications — sequential or parallel ([ParallelNotification]) dispatch
• Streaming — IAsyncEnumerable<T> via CreateStream
• Pipeline Behaviors — compile-time inlined middleware chain (logging, validation, etc.)
• Bridge Packages — WithCache(), WithValidation(), WithResilience(), WithTelemetry() (OpenTelemetry spans + metrics on IRequest<T>.Send), WithAuthorization() ([Authorize]-gated dispatch via ZeroAlloc.Authorization policies)
• Polymorphic Notifications — base interface handlers are automatically included in concrete notification dispatch
• Analyzer Diagnostics — missing handlers, duplicates, and misconfigurations are build errors/warnings
• Zero Allocation — ValueTask, readonly record struct, static dispatch, no closures
• Native AOT Compatible — no reflection at runtime; all dispatch is resolved at compile time by the source generator

Documentation

License

MIT