CQRS Pattern C# (How It Works For Developers)

Step 1: Set Up Your ASP.NET Application

1. Start Visual Studio and choose to create a new project.

2. Search for and select an "ASP.NET Core Web Application" project type. Click Next.

   

3. Give your project a name and set its location. Click Create.
4. Choose the "Web Application (Model-View-Controller)" template for ASP.NET Core. Ensure you're targeting the .NET Core version that suits your requirements. Click Create.

Step 2

Next, you'll want to organize your project for CQRS. You can do this by adding folders to separate commands, queries, and the common interfaces they'll use. In the Solution Explorer, right-click on your project, go to "Add", then "New Folder". Create three folders: "Commands", "Queries", and "Interfaces".

In the "Interfaces" folder, add interfaces for your commands and queries. For a command, you might have an interface ICommandHandler with a method Handle that takes in a command and performs the action. For a query, you could have an interface IQueryHandler with a method Handle that takes in a query and returns data.

Step 3

Now, let's add a command and query to demonstrate. Suppose your application manages tasks, and you want to add a task (command) and retrieve tasks (query).

In the "Interfaces" folder, add two interfaces:

// Define interfaces for your handlers:
public interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}

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

// Define interfaces for your handlers:
public interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}

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

In the "Commands" folder, add a class AddItemCommand with properties for the task details. Also, add a class AddItemCommandHandler that implements ICommandHandler and contains the logic to add a task to the database.

In the "Queries" folder, add a class GetTasksQuery that represents a request for tasks. Add another class GetTasksQueryHandler that implements IQueryHandler and contains the logic to retrieve tasks from the database.

For a simple example, your AddItemCommand might look like this:

public class AddItemCommand
{
    public string Name { get; set; }
    public int Quantity { get; set; }

    // Constructor
    public AddItemCommand(string name, int quantity)
    {
        Name = name;
        Quantity = quantity;
    }
}

public class AddItemCommand
{
    public string Name { get; set; }
    public int Quantity { get; set; }

    // Constructor
    public AddItemCommand(string name, int quantity)
    {
        Name = name;
        Quantity = quantity;
    }
}

And the AddItemCommandHandler:

public class AddItemCommandHandler : ICommandHandler<AddItemCommand>
{
    public void Handle(AddItemCommand command)
    {
        // Here, you'd add the item to your database, for example, to have employee data stored
        Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}");
        // Add database logic here
    }
}

public class AddItemCommandHandler : ICommandHandler<AddItemCommand>
{
    public void Handle(AddItemCommand command)
    {
        // Here, you'd add the item to your database, for example, to have employee data stored
        Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}");
        // Add database logic here
    }
}

Your GetItemsQuery could be empty if it doesn't need any parameters to fetch tasks, and GetItemsQueryHandler might look like:

public class GetItemsQuery
{
    // This class might not need any properties, depending on your query
}

namespace CQRS_testing.Queries
{
    using CQRS_testing.Interfaces;

    public class GetItemsQueryHandler : IQueryHandler<GetItemsQuery, IEnumerable<string>>
    {
        public IEnumerable<string> Handle(GetItemsQuery query)
        {
            // Here, you'd fetch items from your database
            return new List<string> { "Item1", "Item2" };
        }
    }
}

public class GetItemsQuery
{
    // This class might not need any properties, depending on your query
}

namespace CQRS_testing.Queries
{
    using CQRS_testing.Interfaces;

    public class GetItemsQueryHandler : IQueryHandler<GetItemsQuery, IEnumerable<string>>
    {
        public IEnumerable<string> Handle(GetItemsQuery query)
        {
            // Here, you'd fetch items from your database
            return new List<string> { "Item1", "Item2" };
        }
    }
}

In your ASP.NET controllers, you'll use these handlers to process commands and queries. For adding a task, the controller action would create an AddTaskCommand, set its properties from the form data, and then pass it to an AddTaskCommandHandler instance to handle. For retrieving tasks, it would call a GetTasksQueryHandler to get the data and pass it to the view.

Wiring it Up in a Controller

With your commands and queries set up, you can now use them in your controllers. Here's how you might do that in an ItemsController class:

public class ItemsController : Controller
{
    private readonly ICommandHandler<AddItemCommand> _addItemHandler;
    private readonly IQueryHandler<GetItemsQuery, IEnumerable<string>> _getItemsHandler;

    // Constructor injection is correctly utilized here
    public ItemsController(ICommandHandler<AddItemCommand> addItemHandler, IQueryHandler<GetItemsQuery, IEnumerable<string>> getItemsHandler)
    {
        _addItemHandler = addItemHandler;
        _getItemsHandler = getItemsHandler;
    }

    public IActionResult Index()
    {
        // Use the injected _getItemsHandler instead of creating a new instance
        var query = new GetItemsQuery();
        var items = _getItemsHandler.Handle(query);
        return View(items);
    }

    [HttpPost]
    public IActionResult Add(string name, int quantity)
    {
        // Use the injected _addItemHandler instead of creating a new instance
        var command = new AddItemCommand(name, quantity);
        _addItemHandler.Handle(command);
        return RedirectToAction("Index");
    }
}

public class ItemsController : Controller
{
    private readonly ICommandHandler<AddItemCommand> _addItemHandler;
    private readonly IQueryHandler<GetItemsQuery, IEnumerable<string>> _getItemsHandler;

    // Constructor injection is correctly utilized here
    public ItemsController(ICommandHandler<AddItemCommand> addItemHandler, IQueryHandler<GetItemsQuery, IEnumerable<string>> getItemsHandler)
    {
        _addItemHandler = addItemHandler;
        _getItemsHandler = getItemsHandler;
    }

    public IActionResult Index()
    {
        // Use the injected _getItemsHandler instead of creating a new instance
        var query = new GetItemsQuery();
        var items = _getItemsHandler.Handle(query);
        return View(items);
    }

    [HttpPost]
    public IActionResult Add(string name, int quantity)
    {
        // Use the injected _addItemHandler instead of creating a new instance
        var command = new AddItemCommand(name, quantity);
        _addItemHandler.Handle(command);
        return RedirectToAction("Index");
    }
}

To wire everything up, especially if you're using Dependency Injection (DI) in ASP.NET Core, you'll need to register your command and query handlers with the DI container in the Startup.cs file. This way, ASP.NET can provide instances of your handlers when they're needed.

Here's a very basic example of registering a handler:

builder.Services.AddTransient<ICommandHandler<AddItemCommand>, AddItemCommandHandler>();
builder.Services.AddTransient<IQueryHandler<GetItemsQuery, IEnumerable<string>>, GetItemsQueryHandler>();

builder.Services.AddTransient<ICommandHandler<AddItemCommand>, AddItemCommandHandler>();
builder.Services.AddTransient<IQueryHandler<GetItemsQuery, IEnumerable<string>>, GetItemsQueryHandler>();

In the practical application of CQRS, the distinction between the data model for write operations and the one for read operations is foundational, ensuring that the architecture supports varied and optimized approaches to handling data.

Code Example

Now, let's explore how IronPDF can be utilized within a C# application following the Command Query Responsibility Segregation (CQRS) pattern. Below is a simplified example demonstrating how you might use IronPDF within a CQRS setup to generate a PDF report. This example is conceptual and focuses on the generation of a PDF document as a command.

using IronPdf;
using System.Threading.Tasks;

namespace PdfGenerationApp.Commands
{
    public class GeneratePdfReportCommand
    {
        // Command handler that generates a PDF report
        public async Task GenerateReportAsync(string reportContent, string outputPath)
        {
            // Initialize the IronPDF HTML to PDF renderer
            var renderer = new ChromePdfRenderer();
            // Use IronPDF to generate a PDF from HTML content
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(reportContent));
            // Save the generated PDF to a specified path
            pdf.SaveAs(outputPath);
        }
    }
}

using IronPdf;
using System.Threading.Tasks;

namespace PdfGenerationApp.Commands
{
    public class GeneratePdfReportCommand
    {
        // Command handler that generates a PDF report
        public async Task GenerateReportAsync(string reportContent, string outputPath)
        {
            // Initialize the IronPDF HTML to PDF renderer
            var renderer = new ChromePdfRenderer();
            // Use IronPDF to generate a PDF from HTML content
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(reportContent));
            // Save the generated PDF to a specified path
            pdf.SaveAs(outputPath);
        }
    }
}

In this example, GeneratePdfReportCommand represents a command in the CQRS pattern. It includes a method GenerateReportAsync that takes in reportContent as an HTML string and an outputPath where the PDF report will be saved. IronPDF's HtmlToPdf class is used to convert the HTML content to PDF format, which is then saved to the specified path. This setup illustrates how you can integrate PDF generation functionality into your application's architecture, especially in scenarios requiring clear separation of concerns as promoted by CQRS.