Implementing CQRS using ASP.NET core 5.0
The Command and Query Responsibility Segregation (CQRS)
CQRS pattern separates the read and write operations from the its data model. In conventional architectures, the same data model is being used to update and read transactions. This approach functioning well with basic CRUD operations but the models can become unmanageable when the application gets more complex.
For example when querying from datastore, due to the different returned result set, there will be many DTOs introduced and can be very difficult to manage. When performing update in the database, application may contain complex validations and business logic so the data model may ended up with plethora of implementations with heavy objects (not simplified).
Traditional architecture
In CQRS, a separate request/response model is used for each read and write operation and that is a simplified data transfer model with minimum required fields.
CQRS pattern
Let’s now have a quick look at Pros and Cons of using CQRS.
Pros
Single Responsibility — For commands and queries different object models are being consumed. Hence, each model is responsible for only one and single task
Scalability and Maintainability — With CQRS, each service can be implemented separately and possible to host in different servers. That provides the facility to manage them independently.
Suitable for large and complex applications — CQRS allows to define command and queries to granular level, so that minimize the merge conflicts and possible to work in different segment of the application parallelly.
High Performance — Since the object models/services are scaled out individually, each instance could be fine tuned accordingly.
Cons
Complexity — Too much of round trips and lines of code is involved for even a small query function.
Data Consistency — When CQRS is used with different databases for read and write operations, the read data may be stale. Therefore, the read model must be updated with the write model changes.
Let’s first create a SQL table as follows.
CREATE TABLE [dbo].[PersonalDetails](
[Id] [int] IDENTITY(1,1) NOT NULL,
[Title] [nvarchar](20) NULL,
[Name] [varchar](50) NULL,
[City] [varchar](100) NULL,
[DateOfBirth] [date] NULL,
[LoyaltyPoints] [int] NULL,
CONSTRAINT [PK_CustomerDetails] PRIMARY KEY CLUSTERED
(
[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON)
ON [PRIMARY]
) ON [PRIMARY]
GOThen we will create an ASP.NET Core Web Api project.
Next step is to add the entity model in models folder. Models>PersonalDetails.cs
public class PersonalDetails
{
public int Id { get; set; }
public string Title { get; set; }
public string Name { get; set; }
public string City { get; set; }
public int LoyaltyPoints { get; set; }
}PersonalDetails.cs
Create DB context class inside Data folder.
Data>CustomerDbContext.cs
using CustomerManagement.Models;
using Microsoft.EntityFrameworkCore;
namespace CustomerManagement.Data
{
public class CustomerDbContext : DbContext
{
public CustomerDbContext(DbContextOptions<CustomerDbContext>
options) : base(options)
{ }
public DbSet<PersonalDetails> PersonalDetails { get; set; }
protected override void OnModelCreating(ModelBuilder
modelBuilder)
{
modelBuilder.Entity<PersonalDetails>
(p=>p.HasKey(_=>_.Id));
}
}
}CustomerDbContext.cs
make sure to install Microsoft.EntityFrameworkCore and Microsoft.EntityFrameworkCore.SqlServer via NuGet package manager or package manager console.
Install-Package Microsoft.EntityFrameworkCore -Version 5.0.5
Install-Package Microsoft.EntityFrameworkCore.SqlServer -Version 5.0.5Add the connection string in the appsettings.json
appsettings.json
Then in the Startup.cs modify the code as following.
Startup.cs
| Create Command Handler
To save a customer’s personal details, first we have to create a command request model class and this should contain only the required properties. In our scenario, we are using all the properties except ‘Id’ which is anyway auto generated field.
RequestModels>CommandRequests>SaveCustomerRequestModel.cs
namespace CustomerManagement.RequestModels.CommandRequests
{
public class SaveCustomerRequestModel
{
public string Title { get; set; }
public string Name { get; set; }
public string City { get; set; }
public int LoyaltyPoints { get; set; }
}
}SaveCustomerRequestModel.cs
Let’s introduce an asynchronous abstract method to save customer as follows.
Contracts>CommandHandlers>ISaveCustomerCommandHandler.cs
namespace CustomerManagement.Contracts.CommandHandlers
{
public interface ISaveCustomerCommandHandler
{
Task<int> SaveAsync(SaveCustomerRequestModel
saveCustomerRequestModel);
}
}ISaveCustomerCommandHandler.cs
Next, we will implement the ‘SaveAsync’ method in the CommandHandler class.
Handlers>CommandHandlers>SaveCustomerCommandHandler.cs
using CustomerManagement.Contracts.CommandHandlers;
using CustomerManagement.Data;
using CustomerManagement.Models;
using CustomerManagement.RequestModels.CommandRequests;
using System.Threading.Tasks;
namespace CustomerManagement.Handlers.CommandHandlers
{
public class SaveCustomerCommandHandler :
ISaveCustomerCommandHandler
{
private readonly CustomerDbContext context;
public SaveCustomerCommandHandler(CustomerDbContext context)
{
this.context=context;
}
public async Task<int> SaveAsync(SaveCustomerRequestModel
saveCustomerRequestModel)
{
var newCustomer = new PersonalDetails
{
Name = saveCustomerRequestModel.Name,
Title = saveCustomerRequestModel.Title,
City = saveCustomerRequestModel.City,
LoyaltyPoints = saveCustomerRequestModel.LoyaltyPoints
};
this.context.PersonalDetails.Add(newCustomer);
await this.context.SaveChangesAsync();
return newCustomer.Id;
}
}
}SaveCustomerCommandHandler.cs
CustomerDbContext is injected via dependency injection to the command handler and we need to register CommandHandlers in the Startup class.
Startup.cs
Then we will add an end point to save customer details.
Controllers>CustomerController.cs
namespace CustomerManagement.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class CustomerController : ControllerBase
{
private readonly ISaveCustomerCommandHandler
saveCustomerCommandHandler;
public CustomerController(ISaveCustomerCommandHandler
saveCustomerCommandHandler)
{
this.saveCustomerCommandHandler = saveCustomerCommandHandler;
}
[HttpPost]
[Route("save-customer")]
public async Task<IActionResult>
SaveCustomerAsync(SaveCustomerRequestModel requestModel)
{
try
{
var result = await
this.saveCustomerCommandHandler.SaveAsync(requestModel);
return Ok(result);
}
catch
{
throw;
}
}
}
}CustomerController.cs
Let’s verify the changes using postman.
Postman
| Create Query Handler
We will implement a query model to retrieve all customer information from the server. We do not need to have a request model since there is no parameters are being used.
ResponseModels>QueryResponses>AllCustomerQueryResponseModel.cs
namespace CustomerManagement.ResponseModels.QueryResponses
{
public class AllCustomerQueryResponseModel
{
public int Id { get; set; }
public string Title { get; set; }
public string Name { get; set; }
public string City { get; set; }
public int LoyaltyPoints { get; set; }
}
}AllCustomerQueryResponseModel.cs
Then the abstract method in
Contracts>QueryHandler>IAllCustomerQueryHandler.cs
namespace CustomerManagement.Contracts.QueryHandlers
{
public interface IAllCustomerQueryHandler
{
Task<List<AllCustomerQueryResponseModel>> GetAllAsync();
}
}IAllCustomerQueryHandler.cs
Next, we will implement the abstract method.
Handlers>QueryHandler>AllCustomerQueryHandler.cs
namespace CustomerManagement.Handlers.QueryHandler
{
public class AllCustomerQueryHandler : IAllCustomerQueryHandler
{
private readonly CustomerDbContext context;
public AllCustomerQueryHandler(CustomerDbContext context)
{
this.context = context;
}
public async Task<List<AllCustomerQueryResponseModel>>
GetAllAsync()
{
return await this.context.PersonalDetails.Select(s=>new
AllCustomerQueryResponseModel
{
Id=s.Id,
Name=$"{s.Title}.{s.Name }",
City=s.City,LoyaltyPoints=s.LoyaltyPoints
}).ToListAsync();
}
}
}AllCustomerQueryHandler.cs
Then let’s register the query handler with DI in the Startup.cs
QueryHandler- Startup.cs
It’s the final step and we will add an end point in CustomerController.
[HttpGet]
[Route("get-all")]
public async Task<List<AllCustomerQueryResponseModel>>
GetAllCustomerAsync()
{
try
{
return await this.allCustomerQueryHandler.GetAllAsync();
}
catch
{
throw;
}
}GetAllCustomerAsync
Do not forget to inject IAllCustomerQueryHandler via the constructor.
CustomerController.cs
Following is the postman result.
get-all customers Postman
Next we will have a query response model with a parameter. The steps are almost same as retrieving all the customers except using Query Request Model. Since you are familiar with the steps already I will quickly show the steps.
RequestModels>QueryRequests>CustomerIdQueryRequestModel.cs
namespace CustomerManagement.RequestModels.QueryRequests
{
public class CustomerIdQueryRequestModel
{
public int CustomerId { get; set; }
}
}CustomerIdQueryRequestModel.cs
Contracts>QueryHandlers>ICustomerIdQueryHandler.cs
namespace CustomerManagement.Contracts.QueryHandlers
{
public interface ICustomerIdQueryHandler
{
Task<CustomerIdQueryResponseModel>
GetCustomerAsync(CustomerIdQueryRequestModel requestModel);
}
}ICustomerQueryHandler.cs
Handlers>QueryHandler>CustomerIdQueryHandler.cs
namespace CustomerManagement.Handlers.QueryHandler
{
public class CustomerIdQueryHandler : ICustomerIdQueryHandler
{
private readonly CustomerDbContext context;
public CustomerIdQueryHandler(CustomerDbContext context)
{
this.context = context;
}
public async Task<CustomerIdQueryResponseModel> GetCustomerAsync(CustomerIdQueryRequestModel requestModel)
{
var result = await this.context.PersonalDetails.Where(p = >
p.Id == requestModel.CustomerId)
.FirstOrDefaultAsync();
if (result!=null)
{
return new Customer IdQueryResponseModel
{
CustomerId = result.Id,
Name=$"{result.Title}.{result.Name}",
City = result.City
};
}
return null;
}
}
}CustomerIdQueryHandler.cs
in Startup.cs
Startup.cs
in CustomerController.cs
[HttpGet]
[Route("customer-id")] [ProducesResponseType(typeof(CustomerIdQueryResponseModel),StatusCodes.Status200OK)]
public async Task<IActionResult> GetCustomerAsync([FromQuery] CustomerIdQueryRequestModel model)
{
try
{
var result = await
this.customerIdQueryHandler.GetCustomerAsync(model);
if (result!=null)
{
return Ok(result);
}
return NotFound($"Customer Id {model.CustomerId} does not exists
!!");
}
catch
{
throw;
}
}CustomerController.cs
and finally the postman result
Postman
If you had notice the constructor of the CustomerController, everytime a new command or query handler introduced, that has to be injected via constructor and it has be register in the Startup.cs too. Imagine if you had 15 different endpoints with distinct command and query models.
As a solution to this, let’s implement MediatR with CQRS pattern which is again one of the most common implementations of CQRS.
Source: Medium
The Tech Platform
Comments