Medianiz 2.2.1

Medianiz

A lightweight implementation of the mediator pattern for .NET applications, designed to simplify in-process messaging.

Release Versions

• 2.2.1: Fixed handler discovery for services.AddMedianiz(config => config.RegisterHandlersFromAssembly(typeof(Program))) in WebAPI/DDD solutions. Medianiz now scans the non-framework assemblies referenced by the marker assembly, so handlers from layers such as Application are registered automatically.
• 2.2.0: Some libraries were updated and RegisterHandlersFromAssembly was implemented.
• 2.1.0: Some libraries were updated and Medianiz has implementation of Pipeline Behaviors.

Pipeline Behaviors

Medianiz supports Pipeline Behaviors, allowing cross-cutting logic to be executed before and/or after a request handler, following the same model used by MediatR’s IPipelineBehavior.

This feature is useful for implementing concerns such as:

• Logging
• Validation
• Transactions
• Metrics
• Exception handling

Concept

A Pipeline Behavior wraps the execution of a request handler and can:

• Execute code before the handler
• Execute code after the handler
• Stop execution by throwing exceptions
• Decorate or modify the response

Execution is performed as a chained pipeline.

IPipelineBehavior Interface

public delegate Task<TResponse> RequestHandlerDelegate<TResponse>();

public interface IPipelineBehavior<in TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken
    );
}

DOCUMENTATION

Key Features

• Simple request/response handling
• Event publishing to multiple handlers
• First-class async/await support
• CancellationToken integration
• Minimal dependencies
• Works with any DI container

Installation

dotnet add package Medianiz

Basic Usage

1. Configure Services

// In Startup.cs or Program.cs
builder.Services.AddMedianiz(typeof(MyCommandHandler));

For multi-project solutions:

// Reference assemblies by project name
builder.Services.AddMedianizFromAssemblies("MyApp.Application");

2. Define Commands and Handlers

Command:

public record CreateUserCommand(string Email) : IRequest<Guid>;

Handler:

public class CreateUserHandler : IRequestHandler<CreateUserCommand, Guid>
{
    public Task<Guid> Handle(CreateUserCommand request, CancellationToken ct)
    {
        // Business logic here
        return Task.FromResult(Guid.NewGuid());
    }
}

3. Define Events and Handlers

Event:

public record UserCreatedEvent(Guid UserId) : INotification;

Handler:

public class UserCreatedHandler : INotificationHandler<UserCreatedEvent>
{
    public Task Handle(UserCreatedEvent notification, CancellationToken ct)
    {
        // React to the event
        return Task.CompletedTask;
    }
}

4. Use in ASP.NET Core

Controller Example:

[ApiController]
[Route("users")]
public class UsersController : ControllerBase
{
    private readonly IMedianiz _mediator;

    public UsersController(IMedianiz mediator)
    {
        _mediator = mediator;
    }

    [HttpPost]
    public async Task<IActionResult> CreateUser([FromBody] CreateUserCommand command)
    {
        var userId = await _mediator.Send(command);
        return CreatedAtAction(nameof(GetUser), new { id = userId });
    }
}

Advanced Scenarios

Domain Events

public class Order : Entity
{
    public void Complete()
    {
        AddDomainEvent(new OrderCompletedEvent(Id));
    }
}

// Publish events after saving
var order = await _repository.GetOrderAsync();
order.Complete();
await _mediator.PublishDomainEvents(order);

Working with Multiple Assemblies

// Create a marker interface in each project
public interface IApplicationMarker { }

// Then register all needed assemblies
builder.Services.AddMedianiz(
    typeof(Application.Marker),
    typeof(Domain.Marker),
    typeof(Infrastructure.Marker));

Configuration Options

Register Specific Handlers Only

services.AddMedianiz(config =>
{
    config.RegisterHandlersFromAssembly(typeof(Program));
    config.RegisterHandler<SpecialHandler>(); // Manual registration
});

When you use a Web API marker such as typeof(Program), Medianiz also scans the non-framework assemblies referenced by that project so handlers in your Application layer are discovered automatically.

Example in a DDD solution:

// Civika.API
services.AddMedianiz(config =>
{
    config.RegisterHandlersFromAssembly(typeof(Program));
});

// QueryDesempenhoMunicipioCommandHandler can live in Civika.Application
// and will still be registered automatically if Civika.API references it.

Lifecycle Management

// Change handler lifetime (default is Transient)
services.AddMedianiz(typeof(Startup))
    .WithHandlerLifetime(ServiceLifetime.Scoped);

Performance Tips

1. Assembly Filtering: Only scan necessary assemblies
2. Marker Interfaces: Use them to limit handler discovery
3. Lifetime Management: Use Scoped for DB-heavy handlers

Contributing

Pull requests are welcome. For major changes, please open an issue first.

License

GPL 3.0 - See LICENSE for details.