MediatR Publish and Send Methods

The mediator pattern is a software design pattern that enables indirect communication between software components, promoting loose coupling by introducing a mediator object as an intermediary.

By utilizing the Mediator pattern, components are decoupled and unaware of each other, reducing direct dependencies. This enhances flexibility and modularity, simplifying the addition or modification of components without impacting the entire system.

Now, let’s delve into how MediatR empowers the realization of these principles.

Configuring an ASP.NET Core API with MediatR

To begin, let’s install the MediatR package: dotnet add package MediatR

Next, in the Program.cs file, we are going to register MediatR:

builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));

To ensure the effective usage of MediatR, it is crucial to set up its configuration properly.

After successful installation and configuration, we can proceed with creating a new controller responsible for sending messages with MediatR:

[ApiController]
[Route("api/users")]
public class UserController : Controller
{
     private readonly IMediator _mediator;

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

In the UserController, we are going to handle user-related operations within the API. We utilize the IMediator interface, which we inject through the constructor injection. This injection enables the controller to access MediatR functionality for effectively handling messages and requests.

Besides using the IMediator interface, starting from the MediatR library version 9.0 this interface has been split into two separate interfaces ISender and IPublisher. The ISender provides the Send() method capability and IPublisher the Publish() method capability. If you want to know more about this, you can find that in one of our articles about MediatR and CQRS.

The Send Method in MediatR

The Send() method in MediatR facilitates efficient communication between components by handling commands and queries. It is key in promoting decoupling and separation of concerns within the application, resulting in enhanced flexibility and maintainability.

To initiate the process, we first need to create a command class:

public class CreateUserCommand : IRequest<int>
{
     public string UserName { get; set; } = string.Empty;
     public string Email { get; set; } = string.Empty;
}

The CreateUserCommandHandler

Let’s explore the class responsible for creating a new user and returning its ID. This handler class is crucial for the user creation process:

public class CreateUserCommandHandler : IRequestHandler<CreateUserCommand, int>
{
     private readonly IUserRepository _userRepository;

     public CreateUserCommandHandler(IUserRepository userRepository) =>
          _userRepository = userRepository;

     public async Task<int> Handle(CreateUserCommand request, CancellationToken cancellationToken)
     {
          var user = new User { UserName = request.UserName, Email = request.Email };

          return await _userRepository.CreateUserAsync(user);
     }
}

We have a class name CreateUserCommandHandler that implements the IRequestHandler<CreateUserCommand, int> interface. This handler is responsible for processing the CreateUserCommand by creating a new user with the provided username and email. The IUserRepository dependency is injected into the handler’s constructor. The Handle() method asynchronously creates the user using the repository and returns the ID of the newly created user.

Invoking and Verifying Our Request

To invoke our request, we can add the CreateUser() action to our UserController:

[HttpPost]
[ProducesResponseType(StatusCodes.Status201Created)]
public async Task<ActionResult<int>> CreateUser(CreateUserCommand command)
{
     int userId = await _mediator.Send(command);

     return CreatedAtAction(nameof(CreateUser), userId);
}

This action expects a CreateUserCommand parameter and sends it to MediatR using the _mediator.Send() method. Upon invoking the request, it retrieves the result userId and includes it in the CreatedAtAction response. This response serves as the identifier for the newly created user.

Once we send a request to this endpoint, we can verify that MediatR is working as expected: