Using Mediator In Web API's For CQRS Pattern

Creating Commands/Queries and their respective Handlers

In the first step, I will be creating a query to get the list of customers for example. So the query will return all the properties mentioned in the object.

using Domain.DomainDTO;
using MediatR;
using System;
using System.Collections.Generic;

namespace NetCoreLearnings.Application.Queries
{
    public class GetCustomersQuery : IRequest<List<CustomerDto>>
    {
        public Guid Id { get; }
        public string CustomerName { get; }
        public string Country { get; }
        public DateTime JoiningDate { get; }
        public bool PrimeUser { get; }

        public GetCustomersQuery() { }
    }
}

In the next step, let us create a handler for this query called query handler. This query handler will handle the logic for the operation.

using Domain.DomainDTO;
using Domain.Repositories;
using MediatR;
using NetCoreLearnings.Application.Queries;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace NetCoreLearnings.Application.QueryHandlers
{
    public class GetCustomerQueryHandlers : IRequestHandler<GetCustomersQuery, List<CustomerDto>>
    {
        private readonly ICustomerRepository _repo;

        public GetCustomerQueryHandlers(ICustomerRepository repo)
        {
            _repo = repo;
        }

        public Task<List<CustomerDto>> Handle(GetCustomersQuery request, CancellationToken cancellationToken)
        {
            var customers = _repo.GetAll();
            return Task.FromResult(customers.Select(i => new CustomerDto()
            {
                Id = i.Id,
                CustomerName = i.Name,
                JoiningDate = i.JoiningDate,
                PrimeUser = i.PrimeUser
            }).ToList());
        }
    }
}

This handle function will return the list of customers after querying the data from the database.

So we have our handlers ready in our application layer. Let's create an API and see how our API can communicate with the handler with MediatR.

Creating Web API

Let's create a web API controller with a GET API Endpoint. Inject the MediatR into our controller by which we will be sending the queries/commands to our application layer.

using Domain.DomainDTO;
using MediatR;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using NetCoreLearnings.Application.Queries;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace NetCoreLearnings.Controllers.API.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class CustomerController : ControllerBase
    {
        private readonly IMediator _mediator;
        private readonly ILogger<CustomerController> _logger;

        public CustomerController(IMediator mediator, ILogger<CustomerController> logger)
        {
            _mediator = mediator;
            _logger = logger;
        }

        [HttpGet]
        [ProducesResponseType(typeof(List<CustomerDto>), StatusCodes.Status200OK)]
        public async Task<IActionResult> Get()
        {
            var clients = await _mediator.Send(new GetCustomersQuery());
            return Ok(clients);
        }
    }
}

If we see this below line of code, the mediator is responsible for sending the GetCustomersQuery and this is how it interacts with the other object.

var clients = await _mediator.Send(new GetCustomersQuery());

And now in this scenario, the API doesn’t depend upon the application layer and the main object of the API is to send the command and receive the command, but it won’t depend on other objects. In this way, the API and application layer is loosely coupled.

So even if you create unit test cases, there will be two unit tests. One for the API to check if the mediator sent the command or query to the object or not successfully and one to check if the required command or query has returned the object or not. The other unit test is for the command or query handler to process the logic for the operation requested.

This way the MediatR nuget package helps in achieving the CQRS pattern and clean architecture.