MediatR is a simple, unambitious mediator implementation in .NET. It supports request/response, commands, queries, notifications, and events, using a mediator pattern to reduce dependencies between objects. MediatR helps to decouple the in-process sending of messages from handling messages.

Pros

• Simplifies application architecture by reducing direct dependencies between components
• Supports various types of messages: requests, commands, queries, and notifications
• Easy to integrate with dependency injection containers
• Lightweight and has minimal impact on performance

Cons

• Can lead to overuse, potentially complicating simple scenarios
• May introduce additional indirection, making code flow harder to follow
• Requires careful design to avoid creating a "god object" mediator
• Learning curve for developers unfamiliar with the mediator pattern

Code Examples

1. Defining a request and handler:

public class PingRequest : IRequest<string> { }

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

2. Sending a request:

public class SomeService
{
    private readonly IMediator _mediator;

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

    public async Task<string> DoPing()
    {
        return await _mediator.Send(new PingRequest());
    }
}

3. Publishing a notification:

public class ProductAddedNotification : INotification
{
    public int ProductId { get; set; }
}

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

// Publishing the notification
await _mediator.Publish(new ProductAddedNotification { ProductId = 123 });

Getting Started

1. Install MediatR via NuGet:

   dotnet add package MediatR
   

2. Register MediatR in your dependency injection container:

   services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Startup).Assembly));
   

3. Create a request and handler:

   public record MyRequest(int Id) : IRequest<string>;
   
   public class MyHandler : IRequestHandler<MyRequest, string>
   {
       public Task<string> Handle(MyRequest request, CancellationToken cancellationToken)
       {
           return Task.FromResult($"Response for Id: {request.Id}");
       }
   }
   

4. Use MediatR in your application:

   public class MyController : ControllerBase
   {
       private readonly IMediator _mediator;
   
       public MyController(IMediator mediator)
       {
           _mediator = mediator;
       }
   
       public async Task<IActionResult> Get(int id)
       {
           var result = await _mediator.Send(new MyRequest(id));
           return Ok(result);
       }
   }