Dispatchly 1.0.2

Dispatchly

A high-performance, reliable CQRS-style mediator for .NET, inspired by MediatR but optimized for speed and simplicity.

Features

• Fast handler resolution with caching
• Clean CQRS abstractions (IRequest<TResponse>, IRequestHandler<TRequest, TResponse>, IMediator)
• Notifications/events (INotification, INotificationHandler<TNotification>, Publish)
• Pipeline behaviors (IPipelineBehavior<TRequest, TResponse>) for cross-cutting concerns
• Pre- and post-processors (IRequestPreProcessor<TRequest>, IRequestPostProcessor<TRequest, TResponse>) for before/after logic
• Easy dependency injection integration
• .NET Standard 2.1 compatible
• MediatR-like API and extensibility

Installation

Install from NuGet:

dotnet add package Dispatchly

Quick Start

1. Define a Request and Handler

public class Ping : IRequest<string> { }

public class PingHandler : IRequestHandler<Ping, string>
{
    public Task<string> Handle(Ping request, CancellationToken cancellationToken)
    {
        return Task.FromResult("Pong");
    }
}

2. Register Dispatchly in DI

services.AddDispatchly();

3. Use the Mediator

public class MyService
{
    private readonly IMediator mediator;
    public MyService(IMediator mediator)
    {
        this.mediator = mediator;
    }

    public async Task<string> PingAsync()
    {
        return await mediator.Send(new Ping());
    }
}

Notifications (Publish/Subscribe)

public class UserCreated : INotification { public string Email { get; set; } }

public class SendWelcomeEmail : INotificationHandler<UserCreated>
{
    public Task Handle(UserCreated notification, CancellationToken cancellationToken)
    {
        // Send email logic
        return Task.CompletedTask;
    }
}

// Usage:
await mediator.Publish(new UserCreated { Email = "user@email.com" });

Pipeline Behaviors

public class LoggingBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
    {
        Console.WriteLine($"Handling {typeof(TRequest).Name}");
        var response = await next();
        Console.WriteLine($"Handled {typeof(TRequest).Name}");
        return response;
    }
}

Pre- and Post-Processors

public class ValidateRequest : IRequestPreProcessor<Ping>
{
    public Task Process(Ping request, CancellationToken cancellationToken)
    {
        // Validation logic
        return Task.CompletedTask;
    }
}

public class AuditResponse : IRequestPostProcessor<Ping, string>
{
    public Task Process(Ping request, string response, CancellationToken cancellationToken)
    {
        // Auditing logic
        return Task.CompletedTask;
    }
}

Why Dispatchly?

• Minimal allocations and fast handler lookup
• Familiar MediatR-like API and extensibility
• No external dependencies except for DI
• Supports notifications, pipeline behaviors, pre/post-processors

License

MIT