Nast.SimpleMediator 1.1.0

SimpleMediator

A lightweight and efficient implementation of the Mediator pattern for .NET applications.

Support policy: ships a single net8.0 asset validated for .NET 8, .NET 9, and .NET 10.

Features

• Request/response handling with typed results
• Notifications with multiple handlers
• Async stream requests via IAsyncEnumerable<T>
• Dependency-injection integration for Microsoft.Extensions.DependencyInjection
• Explicit handler registration for deterministic startup
• Real pipeline behaviors through IPipelineBehavior<TRequest, TResponse>

Installation

dotnet add package Nast.SimpleMediator

Runtime Support

Validated support matrix: .NET 8, .NET 9, and .NET 10.

SimpleMediator publishes a single net8.0 package asset. Consumers on .NET 8/9/10 use that same asset, and release validation proves the package metadata, runtime matrix, and package contents stay aligned.

Registration

AddMediator() only registers the mediator core services. To discover handlers, pass the assemblies you want scanned explicitly.

using Nast.SimpleMediator;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddMediator(typeof(Program).Assembly);

builder.Services.AddMediator(options =>
{
    options.RegisterServicesFromAssemblies(typeof(Program).Assembly);
    options.AddBehavior<LoggingBehavior>();
});

Requests and Responses

public record GetUserQuery(int UserId) : IRequest<User>;

public sealed class GetUserHandler : IRequestHandler<GetUserQuery, User>
{
    private readonly IUserRepository _repository;

    public GetUserHandler(IUserRepository repository)
    {
        _repository = repository;
    }

    public Task<User> Handle(GetUserQuery request, CancellationToken cancellationToken)
    {
        return _repository.GetByIdAsync(request.UserId);
    }
}

Notifications

public record UserCreatedNotification(int UserId, string Email) : INotification;

public sealed class EmailNotificationHandler : INotificationHandler<UserCreatedNotification>
{
    private readonly IEmailService _emailService;

    public EmailNotificationHandler(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public Task Handle(UserCreatedNotification notification, CancellationToken cancellationToken)
    {
        return _emailService.SendWelcomeEmailAsync(notification.Email);
    }
}

Custom Pipeline Behaviors

Custom behaviors MUST implement IPipelineBehavior<TRequest, TResponse>.

public sealed class LoggingBehavior : IPipelineBehavior<GetUserQuery, User>
{
    private readonly ILogger<LoggingBehavior> _logger;

    public LoggingBehavior(ILogger<LoggingBehavior> logger)
    {
        _logger = logger;
    }

    public async Task<User> Handle(
        GetUserQuery request,
        RequestHandlerDelegate<User> next,
        CancellationToken cancellationToken)
    {
        _logger.LogInformation("Handling {RequestType}", typeof(GetUserQuery).Name);

        var response = await next();

        _logger.LogInformation("Handled {RequestType}", typeof(GetUserQuery).Name);
        return response;
    }
}

This keeps the behavior contract honest: the mediator resolves and executes IPipelineBehavior<TRequest, TResponse> instances in registration order around the real handler.

Breaking Changes in 1.1

• Consumers that relied on ambient loaded-assembly scanning must switch to explicit assembly registration.
• Legacy behavior abstractions that do not implement IPipelineBehavior<TRequest, TResponse> are no longer supported.
• AddMediator() without assemblies is still valid, but it now registers only the mediator core services.

Migration Checklist

1. Replace no-argument registration used for handler discovery with AddMediator(typeof(Program).Assembly) or RegisterServicesFromAssemblies(...).
2. Replace custom behavior interfaces with concrete IPipelineBehavior<TRequest, TResponse> implementations.
3. Keep package/runtime expectations aligned with the validated support matrix: .NET 8, .NET 9, and .NET 10.

License

This project is licensed under the MIT License. See LICENSE for details.