Implementing CQRS With MediatR In ASP.NET Core Application

public class Student
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public double Age { get; set; }
}

public interface IDataAccess
{
    List<Student> GetStudents();
    Student AddStudent(string firstName, string lastName, double age);
    Student GetStudentById(int id);
}

public class DataAccess : IDataAccess
{
    private List<Student> student = new List<Student>();

    public DataAccess()
    {
        student.Add(new Student { Id = 1, FirstName = "Jhon", LastName = "Doe", Age = 18});
        student.Add(new Student { Id = 2, FirstName = "Amelia", LastName = "Amy", Age = 16 });
    }

    public Student GetStudentById(int id)
    {
        var stu = student.Where(t => t.Id == id).FirstOrDefault();
        return stu;
    }

    public List<Student> GetStudents()
    {
        return student;
    }

    public Student AddStudent(string firstName, string lastName, double age)
    {
        Student s = new Student();
        s.FirstName = firstName;
        s.LastName = lastName;
        s.Age = age;
        s.Id = student.Count() + 1;
        student.Add(s);
        return s;
    }
}

Creating Query

Now inside the Queries folder, we will write all our queries. So let's create a query by adding a GetStudentListQuery.cs file inside the Queries folder.

public class GetStudentListQuery : IRequest<List<Student>>
{
}

Here the GetStudenListQuery implements the IRequest interface that confirms the MediatR library that this class is a query/command. As this GetStudentListQuery will return us a List of Students so put the List<student> in the IRequest generic interface.

Creating Handler

For every request(Query/Command) there must be a handler. Handler defines what to do when the client sends a specific request. So for our "GetStudenListQuery" we must define a handler. Lets create a "GetStudentListHandler.cs" file inside Handlers folder.

public class GetStudentListHandler : IRequestHandler<GetStudentListQuery, List<Student>>
{
    private readonly IDataAccess _data;
    public GetStudentListHandler(IDataAccess data)
    {
        _data = data;
    }
    public Task<List<Student>> Handle(GetStudentListQuery request, CancellationToken cancellationToken)
    {
        return Task.FromResult(_data.GetStudents());
    }
}

Here the handler must implement the IRequestHandler interface where we need to pass two generics the first one is the request name that the handler will process (for our example as we will handle GetStudentListQuery so we are passing this) and in the second generic we will pass the output of the request(as this request will return a list of students so we are passing List<Student>).

Creating Command

Now let's do the AddStudent operation as this is an insert operation so this will be our command. so in the Commands folder create a class AddStudentCommand.cs file.

public record AddStudentCommand(string firstName, string lastName, double age) : IRequest<Student>;

As this is also a request so it will implement the IRequest interface. And for this command, we also have to create a handler.

AddStudentHandler.cs

public class AddStudentHandler : IRequestHandler<AddStudentCommand, Student>
{
    private readonly IDataAccess _data;
    public AddStudentHandler(IDataAccess data)
    {
        _data = data;
    }
    public Task<Student> Handle(AddStudentCommand request, CancellationToken cancellationToken)
    {
        return Task.FromResult(_data.AddStudent(request.firstName, request.lastName, request.age));
    }
}

Adding dependency

Now in the API Project inside the startup.cs at ConfigureServices() method register the services for MediatR.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddSwaggerGen(c =>
    {
        c.SwaggerDoc("v1", new OpenApiInfo { Title = "CQRS_Mediator", Version = "v1" });
    });
    services.AddSingleton<IDataAccess, DataAccess>();
    services.AddMediatR(typeof(LibraryEntrypoint).Assembly);
}

Look here while registering the MediatR we load the assembly of the whole Library project(here "LibraryEntrypoint" is an empty class created in the Library project, this is created to just refer to the assembly of the Library project. You can add any of the class if you wish.)

Adding Controller

Now let's create a StudentController and request our "GetStudentListQuery" and "AddStudentCommand" in the controller's GET and POST method.

[Route("api/[controller]")]
[ApiController]
public class StudentController : ControllerBase
{
    private readonly IMediator _mediator;

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

    [HttpGet]
    public async Task<List<Student>> Get()
    {
        return await _mediator.Send(new GetStudentListQuery());
    }

    [HttpPost]
    public async Task<Student> Post([FromBody] Student value)
    {
        var model = new AddStudentCommand(value.FirstName, value.LastName, value.Age);
        return await _mediator.Send(model);
    }
}

So here we are just calling _mediator.Send() method and just passing the Request name that we want and the mediator will call the Request's corresponding Handler to handle the request. So basically the controller doesn't need to know anything about the implementation that makes our controller much more cleaner as the heavy lifting stuff has been managed by the Mediator.

Now if we run the application we can test our API method with Swagger.

So that's a quick introduction and implementation of CQRS in ASP.NET core. Though there are some other important concepts like Event Sourcing in CQRS we will skip it for now. But will try to explain it in the later article.

Thank you. Happy coding!!!