Products

Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller

Developer

Article Blog Forum Interview Beginner News Startup Quiz

Users

Career

Apply Job Internship

Pricing

What is MediatR and how does it relate to Clean Architecture?

Ravi Vishwakarma 448 16 Jun 2025

Ravi Vishwakarma

IT-Hardware & Networking

Ravi Vishwakarma is a dedicated Software Developer with a passion for crafting efficient and innovative solutions. With a keen eye for detail and years of experience, he excels in developing robust software systems that meet client needs. His expertise spans across multiple programming languages and technologies, making him a valuable asset in any software development project.

1 Answers

Ravi Vishwakarma 16 Jun 2025

🧭 What is MediatR?

MediatR is a simple and lightweight .NET library that implements the Mediator Pattern, which helps reduce tight coupling between components by centralizing communication.

In MediatR:

Requests (Commands or Queries) are sent to a mediator instead of calling services or logic directly.
The mediator then invokes the appropriate handler.

NuGet Package:

Install-Package MediatR.Extensions.Microsoft.DependencyInjection

Basic MediatR Flow

Controller → MediatR.Send(request) → Handler → Business Logic → Response

Example

1. Define a Command (write action)

public record CreateStudentCommand(string Name, string Email) : IRequest<bool>;

2. Define a Handler

public class CreateStudentHandler : IRequestHandler<CreateStudentCommand, bool>
{
    private readonly AppDbContext _db;
    public CreateStudentHandler(AppDbContext db) => _db = db;

    public async Task<bool> Handle(CreateStudentCommand request, CancellationToken ct)
    {
        _db.Students.Add(new Student { Name = request.Name, Email = request.Email });
        await _db.SaveChangesAsync();
        return true;
    }
}

3. Send from Controller

public class StudentsController : ControllerBase
{
    private readonly IMediator _mediator;
    public StudentsController(IMediator mediator) => _mediator = mediator;

    [HttpPost]
    public async Task<IActionResult> CreateStudent(CreateStudentCommand command)
    {
        var result = await _mediator.Send(command);
        return Ok(result);
    }
}

MediatR + Clean Architecture

Clean Architecture separates the system into layers:

[ Presentation ]
[ Application  ] ← Business rules (Application layer, UseCases)
[ Domain       ] ← Core business models/rules
[ Infrastructure ] ← EF Core, Email, External APIs, etc.

How MediatR Fits In:

Clean Architecture Layer	Role of MediatR
Application Layer	Hosts MediatR requests and handlers (CQRS)
Presentation Layer	Sends requests via `IMediator.Send(...)`
Infrastructure	Injected dependencies consumed by handlers

Benefits:

Encourages Single Responsibility per handler
Keeps Controllers thin
Promotes decoupling of business logic from delivery (controller/UI)
Facilitates unit testing of handlers
Natural fit for CQRS (Command Query Responsibility Segregation)

CQRS + MediatR + Clean Architecture (Typical Pattern)

[ API Controller ]
        ↓
[ IMediator.Send() ]
        ↓
[ Command / Query Handler ]
        ↓
[ Application Services / Repositories ]

Summary

Aspect	MediatR
Pattern	Mediator
Used for	Decoupling request handling
Works well with	Clean Architecture & CQRS
Pros	Decouples logic, testable, modular
Common Use	Handle Commands & Queries

interview