Mediator

Mediator is a high-performance .NET implementation of the Mediator pattern that uses source generators instead of reflection.

Key features include:

• Native AOT Support: Full support without reflection or runtime code generation, making it ideal for serverless, edge, and mobile environments.
• Build-time Safety: The source generator emits diagnostics (warnings/errors) during development if handlers are missing or configuration is incorrect, preventing runtime errors.
• High Performance: Uses monomorphized Send methods and fast dictionary lookups. For maximum performance, use the concrete Mediator class instead of the IMediator interface.
• Low Cold Start: Optimized for fast startup times.

The benchmarks include a comparison between this library and MediatR across two specific scenarios:

1. Initialization: Resolving IMediator from IServiceProvider.
2. Cold start: Resolving IMediator from IServiceProvider and sending a single request using the IRequest<> overload.

Note: These comparisons do not include a comparison to a direct handler call (which is treated as a baseline in other benchmarks).

The ASPNET_Core_Indirect sample demonstrates how to use Mediator.Abstraction when it is referenced indirectly through other projects. This scenario ensures the Source Generator correctly identifies types even when they are not directly referenced in the entry point project.

To run the application:

1. Use Visual Studio or the dotnet CLI.
2. Once running, the Swagger UI is available at http://localhost:5000/swagger/index.html.
3. To test the API, you can use the get-weather-forecast.http file with the VSCode REST Client extension.

To run the Autofac DI sample, use the dotnet run command. Once the application starts, the API will be available at http://localhost:5000.

$ dotnet run

To build and run the streaming sample project to see the IAsyncEnumerable behavior in action, use the .NET CLI.

$ dotnet run

In your ConfigureServices or equivalent method, call AddMediator(). By default, it uses the Mediator namespace. This method automatically registers your handlers using the source generator.

If you need to specify which assemblies to scan for handlers, use the MediatorOptions configuration overload.

using Mediator;
using Microsoft.Extensions.DependencyInjection;
using System;

var services = new ServiceCollection();

// Default registration
services.AddMediator();

// Registration with specific assemblies
services.AddMediator((MediatorOptions options) => options.Assemblies = [typeof(Ping)]);

using var serviceProvider = services.BuildServiceProvider();
var mediator = serviceProvider.GetRequiredService<IMediator>();

To use Mediator, you need two NuGet packages:

1. Mediator.SourceGenerator: Install this in your edge/outermost project (e.g., ASP.NET Core application or Background worker) to generate the IMediator implementation and dependency injection setup.
2. Mediator.Abstractions: Use this in any project where you define message types and handlers.

Standard message handlers are automatically picked up and added to the DI container via the generated AddMediator method. However, pipeline behaviors must be added manually.

The samples/ directory provides various implementation patterns for Mediator:

• Basic usage: Located in samples/basic/, demonstrating core primitives like requests, notifications, and IPipelineBehavior.
• Application architectures: Located in samples/apps/, showing full-featured usage in APIs and applications (e.g., Clean Architecture).
• Specific use cases: Located in samples/use-cases/, covering patterns like Autofac integration and query caching.
• Showcase: The samples/Showcase/ directory contains the implementation for the features demonstrated in the project's root README.

To run the Request-scoped state sample project, use the standard dotnet CLI command. Once running, you can verify the implementation by calling the provided endpoint and inspecting the custom headers.

$ dotnet run

In this sample, validation is implemented using a pipeline behavior called MessageValidatorBehaviour. This behavior automatically processes any message sent through Mediator that implements the IValidate interface.

Note: This specific implementation uses a ValidationException for control flow to 'return early' from the pipeline. While functional for the sample, for production systems, it is recommended to use types like Result<TResponse, ValidationError> or OneOf<TResponse, ValidationError> to handle success and failure cases without relying on exceptions.