C# : Implementing the CQRS Pattern in .Net Web application

Command Query Responsibility Segregation (CQRS) is a design pattern that separates the responsibilities of handling commands (write operations) and queries (read operations) in an application. In this blog post, we'll explore how to implement the CQRS pattern in C# step by step, using code snippets and clear explanations to ensure understanding for everyone.

Understanding CQRS: CQRS divides the application's data model into separate models for reading and writing. It promotes the idea that different models optimize for different use cases, allowing for better scalability, performance, and maintainability.

Step 1: Define Commands and Queries: Start by defining the commands and queries that your application will support. Commands represent actions that change the application's state, while queries retrieve data from the application.

public class CreateProductCommand
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

public class GetProductByIdQuery
{
    public int Id { get; set; }
}

Step 2: Implement Command and Query Handlers: Create handlers for each command and query. Handlers are responsible for executing the requested actions and returning results.

public interface ICommandHandler<TCommand>
{
    Task HandleAsync(TCommand command);
}

public interface IQueryHandler<TQuery, TResult>
{
    Task<TResult> HandleAsync(TQuery query);
}

public class CreateProductCommandHandler : ICommandHandler<CreateProductCommand>
{
    public async Task HandleAsync(CreateProductCommand command)
    {
        // Logic to create a new product...
    }
}

public class GetProductByIdQueryHandler : IQueryHandler<GetProductByIdQuery, Product>
{
    public async Task<Product> HandleAsync(GetProductByIdQuery query)
    {
        // Logic to retrieve a product by ID...
    }
}

Step 3: Configure Command and Query Routes: Define routes or mappings to associate commands and queries with their respective handlers.

public class CommandRouter
{
    private readonly Dictionary<Type, ICommandHandler> _commandHandlers = new Dictionary<Type, ICommandHandler>();

    public void Register<TCommand>(ICommandHandler<TCommand> handler)
    {
        _commandHandlers[typeof(TCommand)] = handler;
    }

    public async Task ExecuteAsync<TCommand>(TCommand command)
    {
        var handler = (ICommandHandler<TCommand>)_commandHandlers[typeof(TCommand)];
        await handler.HandleAsync(command);
    }
}

public class QueryRouter
{
    private readonly Dictionary<Type, object> _queryHandlers = new Dictionary<Type, object>();

    public void Register<TQuery, TResult>(IQueryHandler<TQuery, TResult> handler)
    {
        _queryHandlers[typeof(TQuery)] = handler;
    }

    public async Task<TResult> ExecuteAsync<TQuery, TResult>(TQuery query)
    {
        var handler = (IQueryHandler<TQuery, TResult>)_queryHandlers[typeof(TQuery)];
        return await handler.HandleAsync(query);
    }
}

Step 4: Usage in Application: Use the configured command and query routers in your application to handle user requests.

public class ProductService
{
    private readonly CommandRouter _commandRouter;
    private readonly QueryRouter _queryRouter;

    public ProductService(CommandRouter commandRouter, QueryRouter queryRouter)
    {
        _commandRouter = commandRouter;
        _queryRouter = queryRouter;
    }

    public async Task CreateProductAsync(CreateProductCommand command)
    {
        await _commandRouter.ExecuteAsync(command);
    }

    public async Task<Product> GetProductByIdAsync(GetProductByIdQuery query)
    {
        return await _queryRouter.ExecuteAsync<GetProductByIdQuery, Product>(query);
    }
}

Conclusion: Implementing the CQRS pattern in C# can lead to more maintainable, scalable, and efficient applications by separating concerns between commands and queries. By following the steps outlined in this guide and using the provided code snippets, you can effectively apply the CQRS pattern to your C# projects, improving their architecture and design.