Ozcorps.Mediator 1.0.0

Ozcorps.Mediator

A lightweight mediator implementation for .NET. Supports CQRS pattern with pipeline behaviors and FluentValidation integration.

Features

• ✅ Request/Response pattern (IRequest, IRequestHandler)
• ✅ Notification pattern (INotification, INotificationHandler)
• ✅ Pipeline behaviors (IPipelineBehavior)
• ✅ Built-in ValidationBehavior with FluentValidation
• ✅ Assembly scanning for automatic handler registration
• ✅ Fluent configuration API
• ✅ Multi-target: net8.0, net9.0, net10.0
• ✅ MIT Licensed - Free forever

Installation

dotnet add package Ozcorps.Mediator

Quick Start

1. Define a Request and Handler

using Ozcorps.Mediator;

// Request
public record GetProductQuery(Guid Id) : IRequest<ProductDto>;

// Handler
public class GetProductHandler : IRequestHandler<GetProductQuery, ProductDto>
{
    public async Task<ProductDto> Handle(GetProductQuery request, CancellationToken cancellationToken)
    {
        // Your logic here
        return new ProductDto(...);
    }
}

2. Register Services

builder.Services.AddOzMediator(cfg =>
{
    cfg.RegisterServicesFromAssembly(typeof(Program).Assembly);
});

3. Use the Mediator

app.MapGet("/products/{id}", async (Guid id, IMediator mediator) =>
{
    var result = await mediator.Send(new GetProductQuery(id));
    return Results.Ok(result);
});

Pipeline Behaviors

Add cross-cutting concerns like validation, logging, or transactions:

public class ValidationBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : notnull
{
    public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken)
    {
        // Before handler
        ValidateRequest(request);
        
        // Call next behavior or handler
        var response = await next();
        
        // After handler
        return response;
    }
}

// Register
builder.Services.AddOzMediator(cfg =>
{
    cfg.RegisterServicesFromAssembly(typeof(Program).Assembly);
    cfg.AddOpenBehavior(typeof(ValidationBehavior<,>));
});

Notifications (Events)

// Event
public record ProductCreatedEvent(Guid ProductId) : INotification;

// Handlers (multiple allowed)
public class SendEmailHandler : INotificationHandler<ProductCreatedEvent>
{
    public async Task Handle(ProductCreatedEvent notification, CancellationToken cancellationToken)
    {
        // Send email
    }
}

public class UpdateCacheHandler : INotificationHandler<ProductCreatedEvent>
{
    public async Task Handle(ProductCreatedEvent notification, CancellationToken cancellationToken)
    {
        // Update cache
    }
}

// Publish (handlers execute sequentially in registration order)
await mediator.Publish(new ProductCreatedEvent(product.Id));

Configuration Options

using Microsoft.Extensions.DependencyInjection;

builder.Services.AddOzMediator(cfg =>
{
    // Register from assembly
    cfg.RegisterServicesFromAssembly(typeof(Program).Assembly);
    
    // Or from type
    cfg.RegisterServicesFromAssemblyContaining<MyHandler>();
    
    // Add pipeline behaviors (executed in order)
    cfg.AddOpenBehavior(typeof(LoggingBehavior<,>));
    cfg.AddOpenBehavior(typeof(ValidationBehavior<,>));
    
    // Set lifetimes
    cfg.WithHandlerLifetime(ServiceLifetime.Scoped);
    cfg.WithMediatorLifetime(ServiceLifetime.Scoped);
});

License

MIT License - Free to use in any project.