Patrón CQRS C# (Cómo funciona para desarrolladores)

Introducción al CQRS

CQRS significa Segregación de Responsabilidad de Consulta de Comandos. Es un patrón que se centra en separar la lectura de datos de su escritura. Esta distinción es crucial por varias razones. En primer lugar, permite una optimización más flexible de cada operación, mejorando el rendimiento y la escalabilidad de la aplicación. Al separar los comandos (escribe) y consultas (lee) puede optimizarlos de forma independiente.

Por ejemplo, una aplicación compleja puede requerir operaciones de lectura rápidas pero tolerar operaciones de escritura más lentas. Al aplicar CQRS, los desarrolladores pueden utilizar diferentes modelos de datos para lecturas y escrituras, segregando la capa de acceso a los datos para adaptarla a las necesidades específicas de cada operación. En este artículo, exploraremos los conceptos del patrón CQRS y el patrón IronPDF biblioteca.

Conceptos básicos y componentes

El corazón de CQRS reside en separar las operaciones de comando y consulta, cada una de las cuales maneja diferentes aspectos de la interacción de datos. Comprender estos componentes es crucial para aplicar el patrón con eficacia.

• Comandos: Son los encargados de actualizar los datos. Los comandos incorporan una lógica de negocio compleja y pueden cambiar el estado de los datos en el almacén de datos actuando sin devolver ninguna información. Los comandos asumen el papel exclusivo de gestionar las tareas de escritura de datos, influyendo directamente en el estado de la aplicación sin producir ninguna salida. Por ejemplo, añadir un nuevo usuario o actualizar los detalles de un producto existente son acciones que se realizan mediante comandos.

• Consultas: Las consultas, gestionadas por un manejador de consultas, recuperan datos u objetos de transferencia de datos sin cambiar el estado del sistema. Son las preguntas que se hacen sobre los datos. Por ejemplo, obtener el perfil de un usuario o listar todos los productos disponibles en un inventario son consultas. Las consultas devuelven datos, pero garantizan que no modifican los datos ni su estado.

  Una de las herramientas más populares para implementar CQRS en aplicaciones .NET es MediatR, una biblioteca de patrones mediadores. Ayuda a reducir el acoplamiento entre los componentes de una aplicación, haciendo que se comuniquen indirectamente. MediatR facilita la gestión de comandos y consultas mediando entre el comando/consulta y su gestor.

Implementación práctica con ASP.NET Core

Implementar el patrón CQRS en ASP.NET Core implica configurar su proyecto para separar comandos y consultas, utilizando una biblioteca como MediatR para mediar entre ellos. A continuación se muestra una descripción general simplificada de cómo puede configurar CQRS en su aplicación ASP.NET Core.

Paso 1: Configure su aplicación ASP.NET

1. Inicie Visual Studio y elija crear un nuevo proyecto.

2. Busque y seleccione un tipo de proyecto "ASP.NET Core Web Application". Haga clic en Siguiente.

   

3. Dale un nombre a tu proyecto y establece su ubicación. Haga clic en Crear.
4. Seleccione la opción "Aplicación Web (Modelo-Vista-Controlador)" para ASP.NET Core. Asegúrese de que está utilizando la versión de .NET Core que se adapta a sus necesidades. Haga clic en Crear.

Paso 2

A continuación, deberá organizar su proyecto para CQRS. Puedes hacerlo añadiendo carpetas para separar los comandos, las consultas y las interfaces comunes que utilizarán. En el Explorador de soluciones, haga clic con el botón derecho del ratón en su proyecto, vaya a "Añadir" y, a continuación, a "Nueva carpeta". Cree tres carpetas: "Comandos", "Consultas" e "Interfaces".

En la carpeta "Interfaces", añada interfaces para sus comandos y consultas. Para un comando, puedes tener una interfaz ICommandHandler con un método Handle que recibe un comando y realiza la acción. Para una consulta, podrías tener una interfaz IQueryHandler con un método Handle que recibe una consulta y devuelve datos.

Paso 3

Ahora, vamos a añadir un comando y una consulta para demostrarlo. Supongamos que su aplicación gestiona tareas y desea añadir una tarea (comando) y recuperar tareas (consulta).

En la carpeta "Interfaces", añade dos interfaces:

//Defina interfaces para sus manejadores:
public interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}
public interface IQueryHandler<TQuery, TResult>
{
    TResult Handle(TQuery query);
}

//Defina interfaces para sus manejadores:
public interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}
public interface IQueryHandler<TQuery, TResult>
{
    TResult Handle(TQuery query);
}

'Defina interfaces para sus manejadores:
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

En la carpeta "Commands", añade una clase AddItemCommand con propiedades para los detalles de la tarea. Además, añade una clase AddItemCommandHandler que implemente ICommandHandler y contenga la lógica para añadir una tarea a la base de datos.

En la carpeta "Queries", añade una clase GetTasksQuery que represente una petición de tareas. Añade otra clase GetTasksQueryHandler que implemente IQueryHandler y contenga la lógica para recuperar tareas de la base de datos.

Para un ejemplo sencillo, su AddItemCommand podría tener este aspecto:

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

Y el AddItemCommandHandler:

public class AddItemCommandHandler : ICommandHandler<AddItemCommand>
{
    public void Handle(AddItemCommand command)
    {
        //  Aquí, usted añadiría el elemento a su base de datos, por ejemplo, para tener almacenados los datos de los empleados
        Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}");
        //  Añada aquí la lógica de la base de datos
    }
}

public class AddItemCommandHandler : ICommandHandler<AddItemCommand>
{
    public void Handle(AddItemCommand command)
    {
        //  Aquí, usted añadiría el elemento a su base de datos, por ejemplo, para tener almacenados los datos de los empleados
        Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}");
        //  Añada aquí la lógica de la base de datos
    }
}

Public Class AddItemCommandHandler
	Implements ICommandHandler(Of AddItemCommand)

	Public Sub Handle(ByVal command As AddItemCommand)
		'  Aquí, usted añadiría el elemento a su base de datos, por ejemplo, para tener almacenados los datos de los empleados
		Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}")
		'  Añada aquí la lógica de la base de datos
	End Sub
End Class

Su GetItemsQuery podría estar vacío si no necesita ningún parámetro para obtener tareas, y GetItemsQueryHandler podría tener el siguiente aspecto:

public class GetItemsQuery
{
    //  Esta clase puede no necesitar ninguna propiedad, dependiendo de su consulta
}
using CQRS_testing.Interfaces;
namespace CQRS_testing.Queries
{
    public class GetItemsQueryHandler : IQueryHandler<GetItemsQuery, IEnumerable<string>>
    {
        public IEnumerable<string> Handle(GetItemsQuery query)
        {
            //  En este caso, obtendrías los elementos de tu base de datos
            return new List<string> { "Item1", "Item2" };
        }
    }
}

public class GetItemsQuery
{
    //  Esta clase puede no necesitar ninguna propiedad, dependiendo de su consulta
}
using CQRS_testing.Interfaces;
namespace CQRS_testing.Queries
{
    public class GetItemsQueryHandler : IQueryHandler<GetItemsQuery, IEnumerable<string>>
    {
        public IEnumerable<string> Handle(GetItemsQuery query)
        {
            //  En este caso, obtendrías los elementos de tu base de datos
            return new List<string> { "Item1", "Item2" };
        }
    }
}

Imports CQRS_testing.Interfaces

Public Class GetItemsQuery
	'  Esta clase puede no necesitar ninguna propiedad, dependiendo de su consulta
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)
			'  En este caso, obtendrías los elementos de tu base de datos
			Return New List(Of String) From {"Item1", "Item2"}
		End Function
	End Class
End Namespace

En sus controladores ASP.NET, utilizará estos manejadores para procesar comandos y consultas. Para añadir una tarea, la acción del controlador crearía un AddTaskCommand, establecería sus propiedades a partir de los datos del formulario, y luego lo pasaría a una instancia AddTaskCommandHandler para que lo gestione. Para recuperar tareas, se llamaría a un GetTasksQueryHandler para obtener los datos y pasarlos a la vista.

Cableado en un controlador

Una vez configurados los comandos y las consultas, ya puedes utilizarlos en tus controladores. Así es como se puede hacer en una clase ItemsController:

public class ItemsController : Controller
{
    private readonly ICommandHandler<AddItemCommand> _addItemHandler;
    private readonly IQueryHandler<GetItemsQuery, IEnumerable<string>> _getItemsHandler;
    //  Aquí se utiliza correctamente la inyección de constructores
    public ItemsController(ICommandHandler<AddItemCommand> addItemHandler, IQueryHandler<GetItemsQuery, IEnumerable<string>> getItemsHandler)
    {
        _addItemHandler = addItemHandler;
        _getItemsHandler = getItemsHandler;
    }
    public IActionResult Index()
    {
        //  Utilice el _getItemsHandler inyectado en lugar de crear una nueva instancia
        var query = new GetItemsQuery();
        var items = _getItemsHandler.Handle(query);
        return View(items);
    }
    [HttpPost]
    public IActionResult Add(string name, int quantity)
    {
        //  Utilice el _addItemHandler inyectado en lugar de crear una nueva instancia
        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;
    //  Aquí se utiliza correctamente la inyección de constructores
    public ItemsController(ICommandHandler<AddItemCommand> addItemHandler, IQueryHandler<GetItemsQuery, IEnumerable<string>> getItemsHandler)
    {
        _addItemHandler = addItemHandler;
        _getItemsHandler = getItemsHandler;
    }
    public IActionResult Index()
    {
        //  Utilice el _getItemsHandler inyectado en lugar de crear una nueva instancia
        var query = new GetItemsQuery();
        var items = _getItemsHandler.Handle(query);
        return View(items);
    }
    [HttpPost]
    public IActionResult Add(string name, int quantity)
    {
        //  Utilice el _addItemHandler inyectado en lugar de crear una nueva instancia
        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))
	'  Aquí se utiliza correctamente la inyección de constructores
	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
		'  Utilice el _getItemsHandler inyectado en lugar de crear una nueva instancia
		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
		'  Utilice el _addItemHandler inyectado en lugar de crear una nueva instancia
		Dim command = New AddItemCommand(name, quantity)
		_addItemHandler.Handle(command)
		Return RedirectToAction("Index")
	End Function
End Class

Para cablear todo, especialmente si está utilizando Inyección de Dependencia (DI) en ASP.NET Core, tendrá que registrar sus manejadores de comandos y consultas con el contenedor DI en el archivo Startup.cs. De este modo, ASP.NET puede proporcionar instancias de sus controladores cuando sean necesarias.

He aquí un ejemplo muy básico de registro de un manejador:

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

En la aplicación práctica de CQRS, la distinción entre el modelo de datos para operaciones de escritura y el de operaciones de lectura es fundamental, ya que garantiza que la arquitectura admita enfoques variados y optimizados para tratar los datos.

IronPDF: C# Biblioteca PDF

IronPDF es una herramienta para desarrolladores que trabajan con el lenguaje de programación C#, que les permite crear, leer y editar documentos PDF directamente dentro de sus aplicaciones. Esta biblioteca es fácil de usar, lo que simplifica la integración de funcionalidades PDF como la generación de informes PDF, facturas o Formularios a partir de HTML código. IronPDF admite varias funciones, como la edición de texto e imágenes en PDF, la configuración de la seguridad de los documentos y la conversión de páginas web a formato PDF. Su versatilidad y facilidad de uso lo convierten en un valioso recurso para los desarrolladores que deseen implementar operaciones PDF en sus proyectos.

Ejemplo de código

Ahora, exploremos como IronPDF puede ser utilizado dentro de una aplicación C# siguiendo la Segregación de Responsabilidad de Consulta de Comandos (CQRS) patrón. A continuación se muestra un ejemplo simplificado que demuestra cómo podría utilizar IronPDF dentro de una configuración CQRS para generar un informe PDF. Este ejemplo es conceptual y se centra en la generación de un documento PDF como comando.

using IronPdf;
using System.Threading.Tasks;
namespace PdfGenerationApp.Commands
{
    public class GeneratePdfReportCommand
    {
        //  Gestor de comandos que genera un informe PDF
        public async Task GenerateReportAsync(string reportContent, string outputPath)
        {
            //  Inicializar el renderizador HTML a PDF de IronPDF
            var renderer = new ChromePdfRenderer();
            //  Utilice IronPDF para generar un PDF a partir de contenido HTML
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(reportContent));
            //  Guardar el PDF generado en una ruta especificada
            pdf.SaveAs(outputPath);
        }
    }
}

using IronPdf;
using System.Threading.Tasks;
namespace PdfGenerationApp.Commands
{
    public class GeneratePdfReportCommand
    {
        //  Gestor de comandos que genera un informe PDF
        public async Task GenerateReportAsync(string reportContent, string outputPath)
        {
            //  Inicializar el renderizador HTML a PDF de IronPDF
            var renderer = new ChromePdfRenderer();
            //  Utilice IronPDF para generar un PDF a partir de contenido HTML
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(reportContent));
            //  Guardar el PDF generado en una ruta especificada
            pdf.SaveAs(outputPath);
        }
    }
}

Imports IronPdf
Imports System.Threading.Tasks
Namespace PdfGenerationApp.Commands
	Public Class GeneratePdfReportCommand
		'  Gestor de comandos que genera un informe PDF
		Public Async Function GenerateReportAsync(ByVal reportContent As String, ByVal outputPath As String) As Task
			'  Inicializar el renderizador HTML a PDF de IronPDF
			Dim renderer = New ChromePdfRenderer()
			'  Utilice IronPDF para generar un PDF a partir de contenido HTML
			Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(reportContent))
			'  Guardar el PDF generado en una ruta especificada
			pdf.SaveAs(outputPath)
		End Function
	End Class
End Namespace

En este ejemplo, GeneratePdfReportCommand representa un comando en el patrón CQRS. Incluye un método GenerateReportAsync que toma reportContent como una cadena HTML y una outputPath donde se guardará el informe PDF. La clase HtmlToPdf de IronPDF se utiliza para convertir el contenido HTML a formato PDF, que luego se guarda en la ruta especificada. Esta configuración ilustra cómo puede integrar la funcionalidad de generación de PDF en la arquitectura de su aplicación, especialmente en escenarios que requieren una clara separación de preocupaciones, tal y como promueve CQRS.

Conclusión

Para terminar, la Segregación de Responsabilidades de Consulta de Comandos (CQRS) ofrece un enfoque estructurado para separar las responsabilidades de lectura y escritura de datos en sus aplicaciones. Esta separación no sólo aclara la arquitectura, sino que también mejora la flexibilidad, escalabilidad y rendimiento de sus sistemas. Siguiendo los pasos descritos anteriormente, puede implementar CQRS en sus aplicaciones ASP.NET Core, utilizando herramientas como MediatR para agilizar la comunicación entre comandos, consultas y sus manejadores.

La integración de IronPDF en su aplicación basada en CQRS amplía aún más sus capacidades, permitiéndole crear, manipular y almacenar documentos PDF sin esfuerzo. Tanto si genera informes, facturas o cualquier tipo de documento, las completas funciones de IronPDF y su sencilla sintaxis lo convierten en una potente herramienta de desarrollo. IronPDF ofrece un **Prueba gratuita para que puedas explorar sus posibilidades antes de comprometerte. Para un uso continuado, las licencias parten de $749, ofreciendo varias opciones para adaptarse a las necesidades de su proyecto.