Mediatr C# (Cómo funciona para desarrolladores)

MediatR es una popular biblioteca .NET que implementa el patrón mediador, permitiendo que los objetos se comuniquen entre sí a través de un mediador, en lugar de hacerlo directamente. Este enfoque es especialmente útil en aplicaciones en las que se desea mantener un bajo nivel de acoplamiento entre los componentes. En este artículo, examinaremos en detalle MediatR en el contexto del desarrollo en C#, proporcionando ejemplos prácticos y orientación sobre cómo integrarlo en sus proyectos de aplicaciones web. También exploraremos laBiblioteca IronPDF para funciones PDF en aplicaciones .NET para la integración de funcionalidades PDF en proyectos ASP.NET Core.

Introducción al patrón mediador y a MediatR

El patrón mediador es un patrón de diseño de software que facilita la interacción entre objetos de forma que se reducen las dependencias directas entre ellos, promoviendo el acoplamiento flexible. MediatR proporciona una implementación de mediador poco ambiciosa, centrada en la simplicidad y la eficiencia a la hora de facilitar la comunicación entre objetos.

En el corazón de la biblioteca MediatR se encuentra el concepto de peticiones y múltiples gestores. En el punto de solicitud, un objeto encapsula los detalles de la operación o acción, a la espera de ser procesados por el mecanismo MediatR. Cada solicitud es manejada por un correspondiente manejador o método handle, que contiene la lógica de negocio para ejecutar la solicitud. Esta estructura es especialmente útil para implementar la segregación de responsabilidades de consulta de comandos(CQRS) donde la separación de las operaciones de lectura y escritura puede dar lugar a arquitecturas de software más fáciles de mantener y escalables.

Instalación de MediatR en un proyecto .NET Core mediante la consola del gestor de paquetes

Para empezar a utilizar MediatR en un proyecto ASP.NET Core, primero debe instalar el paquete MediatR. Esto se puede hacer a través de la consola del gestor de paquetes en Visual Studio con el siguiente comando:

Install-Package MediatR

Después de instalar el paquete, es necesario añadir MediatR al contenedor de inyección de dependencias de ASP.NET Core. Esto se hace normalmente en el archivo Program.cs o Startup.cs de su proyecto de aplicación web, dependiendo de la versión de ASP.NET Core que esté utilizando. He aquí cómo hacerlo en un programa con una capa de presentación API mínima.

// writing code
var builder = WebApplication.CreateBuilder(args);
// Add MediatR
builder.Services.AddMediatR(typeof(Program).Assembly);
var app = builder.Build();

// writing code
var builder = WebApplication.CreateBuilder(args);
// Add MediatR
builder.Services.AddMediatR(typeof(Program).Assembly);
var app = builder.Build();

' writing code
Dim builder = WebApplication.CreateBuilder(args)
' Add MediatR
builder.Services.AddMediatR(GetType(Program).Assembly)
Dim app = builder.Build()

En la clase de programa, **var builder = WebApplication.CreateBuilder(args)Ÿ Inicializa la aplicación web, preparando el escenario para la integración de MediatR.

Creación de la primera solicitud y del primer gestor de MediatR

Las solicitudes de MediatR son clases sencillas, como un gestor de correo electrónico de clase pública, que representan los datos necesarios para realizar una operación específica. A continuación se muestra un ejemplo de una clase pública de solicitud que representa un comando para crear un nuevo usuario.

public class CreateUserCommand : IRequest<int>
{
    public string Name { get; set; }
    public string Email { get; set; }
    public int id {get; set;}
}

public class CreateUserCommand : IRequest<int>
{
    public string Name { get; set; }
    public string Email { get; set; }
    public int id {get; set;}
}

Public Class CreateUserCommand
	Implements IRequest(Of Integer)

	Public Property Name() As String
	Public Property Email() As String
	Public Property id() As Integer
End Class

En este ejemplo, la clase CreateUserCommand implementa la función IRequest, indicando que esta petición espera una respuesta entera, que podría representar el ID del usuario creado.

A continuación, necesitas crear un manejador para esta petición. Dentro de cada manejador, el método public async Task Handle es el núcleo donde se ejecuta la lógica de la solicitud:

public class CreateUserHandler : IRequestHandler<CreateUserCommand, int>
{
    public async Task<int> Handle(CreateUserCommand command, CancellationToken token)
    {
        // Implement logic to create user here
        // For this example, let's pretend we create a user and return the ID
        return await Task.FromResult(1); // Assume the user's ID is 1
    }
}

public class CreateUserHandler : IRequestHandler<CreateUserCommand, int>
{
    public async Task<int> Handle(CreateUserCommand command, CancellationToken token)
    {
        // Implement logic to create user here
        // For this example, let's pretend we create a user and return the ID
        return await Task.FromResult(1); // Assume the user's ID is 1
    }
}

Public Class CreateUserHandler
	Implements IRequestHandler(Of CreateUserCommand, Integer)

	Public Async Function Handle(ByVal command As CreateUserCommand, ByVal token As CancellationToken) As Task(Of Integer)
		' Implement logic to create user here
		' For this example, let's pretend we create a user and return the ID
		Return Await Task.FromResult(1) ' Assume the user's ID is 1
	End Function
End Class

Utilización de MediatR en su aplicación

Siguiendo el mismo proceso utilizado para configurar MediatR, podrá integrarlo en el flujo de trabajo de su aplicación. Esto se hace normalmente a través de un controlador o endpoint en una aplicación ASP.NET Core. He aquí un ejemplo utilizando un controlador API:

[ApiController]
[Route("[controller]")]
public class UsersController : ControllerBase
{
    private readonly IMediator _mediator;
    public UsersController(IMediator mediator)
    {
        _mediator = mediator;
    }
    [HttpPost]
    public async Task<ActionResult<int>> Create(CreateUserCommand command)
    {
        var userId = await _mediator.Send(command);
        return CreatedAtRoute("GetUser", new { id = userId }, command);
    }
}

[ApiController]
[Route("[controller]")]
public class UsersController : ControllerBase
{
    private readonly IMediator _mediator;
    public UsersController(IMediator mediator)
    {
        _mediator = mediator;
    }
    [HttpPost]
    public async Task<ActionResult<int>> Create(CreateUserCommand command)
    {
        var userId = await _mediator.Send(command);
        return CreatedAtRoute("GetUser", new { id = userId }, command);
    }
}

<ApiController>
<Route("[controller]")>
Public Class UsersController
	Inherits ControllerBase

	Private ReadOnly _mediator As IMediator
	Public Sub New(ByVal mediator As IMediator)
		_mediator = mediator
	End Sub
	<HttpPost>
	Public Async Function Create(ByVal command As CreateUserCommand) As Task(Of ActionResult(Of Integer))
		Dim userId = Await _mediator.Send(command)
		Return CreatedAtRoute("GetUser", New With {Key .id = userId}, command)
	End Function
End Class

En este controlador, el método de acción Create envía el comando CreateUserCommand a MediatR llamando a _mediator.Send(comando). A continuación, MediatR busca el gestor apropiado para este comando y lo ejecuta. El resultado se devuelve y se utiliza para generar una respuesta en el mismo proceso.

Más allá de las peticiones básicas: Notificaciones y comportamientos

MediatR también admite notificaciones y comportamientos. Las notificaciones son mensajes a los que se pueden suscribir y manejar múltiples manejadores, lo que permite un enfoque más orientado a eventos dentro de su aplicación. Los comportamientos, por su parte, se asemejan a un middleware para sus solicitudes MediatR, permitiéndole implementar aspectos transversales como el registro, la validación o la gestión de transacciones.

Introducción a la biblioteca IronPDF

IronPDF es una biblioteca C# diseñada para desarrolladores .NET que necesitan una forma sencilla de crear, editar y trabajar con archivos PDF en sus aplicaciones sin problemas de escritura. Los desarrolladores pueden generar archivos PDF sin necesidad de recurrir a API complejas simplemente convirtiendo páginas web oCódigo HTML directamente en formato PDF. IronPDF no se limita a crear archivos PDF; también ofrece funciones para editar PDF, como añadir texto, imágenes y páginas, o incluso rellenar y editar formularios dentro de documentos PDF. Los desarrolladores pueden trabajar de forma exhaustiva con archivos PDF, incluyendo tareas como combinar, dividir y proteger archivos PDF con contraseñas y permisos.

Ejemplo de código

En este ejemplo, supongamos que la solicitud de MediatR se refiere a algún tipo de contenido multimedia o metadatos que queremos incluir en nuestro PDF. Dado que MediatR no está directamente relacionado con la funcionalidad de IronPDF, abordaremos este tema creando un documento PDF a partir de contenido HTML que incluya información multimedia o referencias como un buen punto de partida.

using IronPdf;
public class PdfGenerator
{
    public void CreatePdfWithMediaInfo(string htmlContent)
    {
        License.LicenseKey = "License-Key";
        // Initialize the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();
        // Example HTML content - replace this with your actual HTML content
        // Here, "htmlContent" should include your MediatR information in HTML format
        string htmlTemplate = $@"
            <html>
            <head>
                <title>Media Information</title>
            </head>
            <body>
                <h1>Media Details</h1>
                <!-- Insert your media information here -->
                {htmlContent}
            </body>
            </html>";
        // Convert HTML string to PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlTemplate);
        pdfDocument.SaveAs("MediaInformation.pdf");
    }
}
class Program
{
    static void Main(string [] args)
    {
        // Example HTML content with MediatR information
        string htmlContent = @"
            <div>
                <h2>MediaTR Information</h2>
                <p>MediaTR is a media tracking system...</p>
            </div>";
        // Create an instance of PdfGenerator
        PdfGenerator pdfGenerator = new PdfGenerator();
        // Call the CreatePdfWithMediaInfo method to generate the PDF
        pdfGenerator.CreatePdfWithMediaInfo(htmlContent);
        Console.WriteLine("PDF generated successfully.");
    }
}

using IronPdf;
public class PdfGenerator
{
    public void CreatePdfWithMediaInfo(string htmlContent)
    {
        License.LicenseKey = "License-Key";
        // Initialize the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();
        // Example HTML content - replace this with your actual HTML content
        // Here, "htmlContent" should include your MediatR information in HTML format
        string htmlTemplate = $@"
            <html>
            <head>
                <title>Media Information</title>
            </head>
            <body>
                <h1>Media Details</h1>
                <!-- Insert your media information here -->
                {htmlContent}
            </body>
            </html>";
        // Convert HTML string to PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlTemplate);
        pdfDocument.SaveAs("MediaInformation.pdf");
    }
}
class Program
{
    static void Main(string [] args)
    {
        // Example HTML content with MediatR information
        string htmlContent = @"
            <div>
                <h2>MediaTR Information</h2>
                <p>MediaTR is a media tracking system...</p>
            </div>";
        // Create an instance of PdfGenerator
        PdfGenerator pdfGenerator = new PdfGenerator();
        // Call the CreatePdfWithMediaInfo method to generate the PDF
        pdfGenerator.CreatePdfWithMediaInfo(htmlContent);
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Public Class PdfGenerator
	Public Sub CreatePdfWithMediaInfo(ByVal htmlContent As String)
		License.LicenseKey = "License-Key"
		' Initialize the HtmlToPdf renderer
		Dim renderer = New ChromePdfRenderer()
		' Example HTML content - replace this with your actual HTML content
		' Here, "htmlContent" should include your MediatR information in HTML format
		Dim htmlTemplate As String = $"
            <html>
            <head>
                <title>Media Information</title>
            </head>
            <body>
                <h1>Media Details</h1>
                <!-- Insert your media information here -->
                {htmlContent}
            </body>
            </html>"
		' Convert HTML string to PDF
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlTemplate)
		pdfDocument.SaveAs("MediaInformation.pdf")
	End Sub
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Example HTML content with MediatR information
		Dim htmlContent As String = "
            <div>
                <h2>MediaTR Information</h2>
                <p>MediaTR is a media tracking system...</p>
            </div>"
		' Create an instance of PdfGenerator
		Dim pdfGenerator As New PdfGenerator()
		' Call the CreatePdfWithMediaInfo method to generate the PDF
		pdfGenerator.CreatePdfWithMediaInfo(htmlContent)
		Console.WriteLine("PDF generated successfully.")
	End Sub
End Class

En este fragmento de código, htmlContent es una variable que debe contener la información multimedia en formato HTML. Puede incluir texto, imágenes, enlaces a vídeos o cualquier otro contenido compatible con HTML. IronPDF convertirá este contenido HTML en un documento PDF, conservando el diseño y el formato especificados en el HTML.

Conclusión

Siguiendo los pasos descritos en este artículo, ahora deberías tener una base sólida para incorporar MediatR en tus proyectos, empezando por la gestión básica de comandos y consultas hasta aprovechar las funciones más avanzadas como las notificaciones y los comportamientos. A medida que su aplicación crece y evoluciona, MediatR ofrece herramientas y patrones que pueden ayudar a mantener su código base limpio, mantenible y escalable.

Para concluir, cabe señalar que explorar e integrar distintas bibliotecas y herramientas, como IronPDF, puede mejorar aún más sus proyectos .NET. IronPDF ofrece unprueba gratuita de las funciones avanzadas de PDF. Para proyectos que requieran funciones avanzadas de PDF, las licencias de IronPDF comienzan a partir de 749 dólares, lo que ofrece una solución sólida para desarrolladores .NET que buscan ampliar las funcionalidades de sus aplicaciones.