IronAlpine.Mediator.DependencyInjection 0.2.1

IronAlpine Mediator

IronAlpine.Mediator is a lightweight mediator stack for .NET applications.

Packages

1. IronAlpine.Mediator.Abstractions

• Contracts for requests, notifications, stream requests, and pipeline behaviors.

2. IronAlpine.Mediator

• Runtime implementation for dispatching request/response, notifications, and streams.

3. IronAlpine.Mediator.DependencyInjection

• IServiceCollection integration with assembly scanning and open behavior registration.

Target Frameworks

• .NET 9
• .NET 10

Installation

Typical application usage:

dotnet add package IronAlpine.Mediator.DependencyInjection

Contracts-only usage:

dotnet add package IronAlpine.Mediator.Abstractions

Custom runtime wiring:

dotnet add package IronAlpine.Mediator
dotnet add package IronAlpine.Mediator.Abstractions

Request/Response

using IronAlpine.Mediator.Abstractions.Contracts;

public sealed record GetUserQuery(Guid UserId) : IRequest<UserDto>;

public sealed class GetUserQueryHandler : IRequestHandler<GetUserQuery, UserDto>
{
    public Task<UserDto> Handle(GetUserQuery request, CancellationToken cancellationToken)
        => Task.FromResult(new UserDto(request.UserId, "demo.user"));
}

public sealed record UserDto(Guid Id, string Username);

Registration

using IronAlpine.Mediator.DependencyInjection.Extensions;

builder.Services.AddIronAlpineMediator(cfg =>
{
    cfg.RegisterServicesFromAssemblyContaining<GetUserQueryHandler>();
});

Usage

using IronAlpine.Mediator.Abstractions.Contracts;

public sealed class UserService
{
    private readonly IMediator _mediator;

    public UserService(IMediator mediator)
    {
        _mediator = mediator;
    }

    public Task<UserDto> GetUserAsync(Guid id, CancellationToken ct)
        => _mediator.Send(new GetUserQuery(id), ct);
}

Notifications

using IronAlpine.Mediator.Abstractions.Contracts;

public sealed record UserCreated(Guid UserId) : INotification;

public sealed class AuditHandler : INotificationHandler<UserCreated>
{
    public Task Handle(UserCreated notification, CancellationToken cancellationToken)
        => Task.CompletedTask;
}

Configure publish strategy:

using IronAlpine.Mediator.Abstractions.Contracts;
using IronAlpine.Mediator.DependencyInjection.Extensions;

builder.Services.AddIronAlpineMediator(cfg =>
{
    cfg.RegisterServicesFromAssemblyContaining<AuditHandler>();
    cfg.UseNotificationPublishStrategy(NotificationPublishStrategy.Sequential);
});

Pipeline Behaviors

using IronAlpine.Mediator.Abstractions.Contracts;

public sealed class LoggingBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken)
    {
        return await next();
    }
}

Register open behavior:

builder.Services.AddIronAlpineMediator(cfg =>
{
    cfg.RegisterServicesFromAssemblyContaining<GetUserQueryHandler>();
    cfg.AddOpenBehavior(typeof(LoggingBehavior<,>));
});

Streaming

using System.Runtime.CompilerServices;
using IronAlpine.Mediator.Abstractions.Contracts;

public sealed record StreamUsersQuery() : IStreamRequest<UserDto>;

public sealed class StreamUsersQueryHandler : IStreamRequestHandler<StreamUsersQuery, UserDto>
{
    public async IAsyncEnumerable<UserDto> Handle(
        StreamUsersQuery request,
        [EnumeratorCancellation] CancellationToken cancellationToken)
    {
        yield return new UserDto(Guid.NewGuid(), "user-1");
        yield return new UserDto(Guid.NewGuid(), "user-2");
        await Task.CompletedTask;
    }
}

Consume stream:

await foreach (var item in mediator.CreateStream(new StreamUsersQuery(), ct))
{
    // process item
}