Padrão CQRS em C# (Como funciona para desenvolvedores)

Passo 1: Configure sua aplicação ASP.NET

1. Inicie o Visual Studio e escolha criar um novo projeto.

2. Procure e selecione um projeto do tipo "Aplicação Web ASP.NET Core ". Clique em Avançar.

   

3. Dê um nome ao seu projeto e defina sua localização. Clique em Criar.
4. Escolha o modelo "Aplicação Web (Model-View-Controller)" para ASP.NET Core. Certifique-se de estar utilizando a versão do .NET Core que atenda às suas necessidades. Clique em Criar.

Etapa 2

Em seguida, você precisará organizar seu projeto para CQRS. Você pode fazer isso adicionando pastas para separar comandos, consultas e as interfaces comuns que eles usarão. No Explorador de Soluções, clique com o botão direito do mouse no seu projeto, vá em "Adicionar" e, em seguida, em "Nova Pasta". Crie três pastas: "Comandos", "Consultas" e "Interfaces".

Na pasta "Interfaces", adicione interfaces para seus comandos e consultas. Para um comando, você pode ter uma interface ICommandHandler com um método Handle que recebe um comando e executa a ação. Para uma consulta, você poderia ter uma interface IQueryHandler com um método Handle que recebe uma consulta e retorna dados.

Etapa 3

Agora, vamos adicionar um comando e uma consulta para demonstrar. Suponha que seu aplicativo gerencie tarefas e você queira adicionar uma tarefa (comando) e recuperar tarefas (consulta).

Na pasta "Interfaces", adicione duas 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);
}

' Define interfaces for your handlers:
Public Interface ICommandHandler(Of TCommand)
	Sub Handle(ByVal command As TCommand)
End Interface

Public Interface IQueryHandler(Of TQuery, TResult)
	Function Handle(ByVal query As TQuery) As TResult
End Interface

Na pasta "Comandos", adicione uma classe AddItemCommand com propriedades para os detalhes da tarefa. Adicione também uma classe AddItemCommandHandler que implemente a interface ICommandHandler e contenha a lógica para adicionar uma tarefa ao banco de dados.

Na pasta "Consultas", adicione uma classe GetTasksQuery que represente uma solicitação de tarefas. Adicione outra classe, GetTasksQueryHandler, que implemente a interface IQueryHandler e contenha a lógica para recuperar tarefas do banco de dados.

Para dar um exemplo simples, seu comando AddItemCommand poderia ser assim:

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;
    }
}

Public Class AddItemCommand
	Public Property Name() As String
	Public Property Quantity() As Integer

	' Constructor
	Public Sub New(ByVal name As String, ByVal quantity As Integer)
		Me.Name = name
		Me.Quantity = quantity
	End Sub
End Class

E o manipulador de comando AddItem:

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
    }
}

Public Class AddItemCommandHandler
	Implements ICommandHandler(Of AddItemCommand)

	Public Sub Handle(ByVal command As AddItemCommand)
		' 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
	End Sub
End Class

Sua GetItemsQuery pode estar vazia se não precisar de nenhum parâmetro para buscar tarefas, e o GetItemsQueryHandler pode ter a seguinte aparência:

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" };
        }
    }
}

Imports CQRS_testing.Interfaces

Public Class GetItemsQuery
	' This class might not need any properties, depending on your query
End Class

Namespace CQRS_testing.Queries

	Public Class GetItemsQueryHandler
		Implements IQueryHandler(Of GetItemsQuery, IEnumerable(Of String))

		Public Function Handle(ByVal query As GetItemsQuery) As IEnumerable(Of String)
			' Here, you'd fetch items from your database
			Return New List(Of String) From {"Item1", "Item2"}
		End Function
	End Class
End Namespace

Em seus controladores ASP.NET , você usará esses manipuladores para processar comandos e consultas. Para adicionar uma tarefa, a ação do controlador criaria um AddTaskCommand , definiria suas propriedades a partir dos dados do formulário e, em seguida, o passaria para uma instância de AddTaskCommandHandler para ser processado. Para recuperar tarefas, seria chamado um GetTasksQueryHandler para obter os dados e passá-los para a visualização.

Conectando-o a um controlador

Com seus comandos e consultas configurados, agora você pode usá-los em seus controladores. Eis como você pode fazer isso em uma classe ItemsController :

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");
    }
}

Public Class ItemsController
	Inherits Controller

	Private ReadOnly _addItemHandler As ICommandHandler(Of AddItemCommand)
	Private ReadOnly _getItemsHandler As IQueryHandler(Of GetItemsQuery, IEnumerable(Of String))

	' Constructor injection is correctly utilized here
	Public Sub New(ByVal addItemHandler As ICommandHandler(Of AddItemCommand), ByVal getItemsHandler As IQueryHandler(Of GetItemsQuery, IEnumerable(Of String)))
		_addItemHandler = addItemHandler
		_getItemsHandler = getItemsHandler
	End Sub

	Public Function Index() As IActionResult
		' Use the injected _getItemsHandler instead of creating a new instance
		Dim query = New GetItemsQuery()
		Dim items = _getItemsHandler.Handle(query)
		Return View(items)
	End Function

	<HttpPost>
	Public Function Add(ByVal name As String, ByVal quantity As Integer) As IActionResult
		' Use the injected _addItemHandler instead of creating a new instance
		Dim command = New AddItemCommand(name, quantity)
		_addItemHandler.Handle(command)
		Return RedirectToAction("Index")
	End Function
End Class

Para configurar tudo, especialmente se você estiver usando Injeção de Dependência (DI) no ASP.NET Core, será necessário registrar seus manipuladores de comandos e consultas no contêiner de DI no arquivo Startup.cs . Dessa forma, o ASP.NET poderá fornecer instâncias dos seus manipuladores quando necessário.

Aqui está um exemplo muito básico de como registrar um manipulador:

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>();

builder.Services.AddTransient(Of ICommandHandler(Of AddItemCommand), AddItemCommandHandler)()
builder.Services.AddTransient(Of IQueryHandler(Of GetItemsQuery, IEnumerable(Of String)), GetItemsQueryHandler)()

Na aplicação prática do CQRS, a distinção entre o modelo de dados para operações de escrita e o modelo para operações de leitura é fundamental, garantindo que a arquitetura suporte abordagens variadas e otimizadas para o tratamento de dados.

Exemplo de código

Agora, vamos explorar como o IronPDF pode ser utilizado em uma aplicação C# seguindo o padrão CQRS (Command Query Responsibility Segregation). A seguir, um exemplo simplificado que demonstra como você pode usar o IronPDF em uma configuração CQRS para gerar um relatório em PDF. Este exemplo é conceitual e foca na geração de um documento PDF como um comando.

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);
        }
    }
}

Imports IronPdf
Imports System.Threading.Tasks

Namespace PdfGenerationApp.Commands
	Public Class GeneratePdfReportCommand
		' Command handler that generates a PDF report
		Public Async Function GenerateReportAsync(ByVal reportContent As String, ByVal outputPath As String) As Task
			' Initialize the IronPDF HTML to PDF renderer
			Dim renderer = New ChromePdfRenderer()
			' Use IronPDF to generate a PDF from HTML content
			Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(reportContent))
			' Save the generated PDF to a specified path
			pdf.SaveAs(outputPath)
		End Function
	End Class
End Namespace

Neste exemplo, GeneratePdfReportCommand representa um comando no padrão CQRS. Inclui um método GenerateReportAsync que recebe reportContent como uma string HTML e um outputPath onde o relatório em PDF será salvo. A classe HtmlToPdf do IronPDF é usada para converter o conteúdo HTML para o formato PDF, que é então salvo no caminho especificado. Esta configuração ilustra como você pode integrar a funcionalidade de geração de PDF na arquitetura do seu aplicativo, especialmente em cenários que exigem uma clara separação de responsabilidades, conforme promovido pelo CQRS.