Mediatr C# (Comment ça marche pour les développeurs)

MediatR est une bibliothèque .NET populaire qui met en œuvre le modèle de médiateur, permettant aux objets de communiquer entre eux par l'intermédiaire d'un médiateur, plutôt que directement. Cette approche est particulièrement utile dans les applications où il est souhaitable de maintenir un faible niveau de couplage entre les composants. Dans cet article, nous allons examiner en détail MediatR dans le contexte du développement C#, en fournissant des exemples pratiques et des conseils sur la manière de l'intégrer dans vos projets d'applications web. Nous explorerons également les Bibliothèque IronPDF pour l'intégration de fonctionnalités PDF dans les projets ASP.NET Core.

Introduction au modèle du médiateur et à MediatR

Le modèle du médiateur est un modèle de conception logicielle qui facilite l'interaction entre les objets de manière à réduire les dépendances directes entre eux, favorisant ainsi un couplage lâche. MediatR propose une mise en œuvre peu ambitieuse du médiateur, axée sur la simplicité et l'efficacité dans la facilitation de la communication entre les objets.

Au cœur de la bibliothèque MediatR se trouve le concept de requêtes et de gestionnaires multiples. Au point de demande, un objet encapsule les détails de l'opération ou de l'action, en attendant d'être traité par le mécanisme MediatR. Chaque demande est traitée par un gestionnaire ou une méthode de gestion correspondant(e), qui contient la logique métier permettant d'exécuter la demande. Cette structure est particulièrement utile pour mettre en œuvre la séparation des responsabilités des requêtes de commande (CQRS) où la séparation des opérations de lecture et d'écriture peut conduire à des architectures logicielles plus faciles à maintenir et plus évolutives.

Installation de MediatR dans un projet .NET Core à l'aide de la console du gestionnaire de paquets

Pour commencer à utiliser MediatR dans un projet ASP.NET Core, vous devez d'abord installer le package MediatR. Cette opération peut être effectuée dans la console du gestionnaire de paquets de Visual Studio à l'aide de la commande suivante :

Install-Package MediatR

Après avoir installé le package, il est nécessaire d'ajouter MediatR au conteneur d'injection de dépendances ASP.NET Core. Cela se fait généralement dans le fichier Program.cs ou Startup.cs de votre projet d'application web, en fonction de la version d'ASP.NET Core que vous utilisez. Voici comment vous pouvez le faire dans un programme avec une couche de présentation API minimale.

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

Dans la classe de programme, var builder = WebApplication.CreateBuilder(args); initialise l'application web, préparant le terrain pour l'intégration de MediatR.

Création de votre première requête et de votre premier gestionnaire MediatR

Les requêtes MediatR sont des classes simples, telles que la classe publique emailhandler, qui représentent les données nécessaires à l'exécution d'une opération spécifique. Voici un exemple de classe publique de requête qui représente une commande de création d'un nouvel utilisateur.

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

Dans cet exemple, la classe CreateUserCommand implémente la classe IRequest, indiquant que cette demande attend une réponse sous la forme d'un nombre entier, qui pourrait représenter l'identifiant de l'utilisateur créé.

Ensuite, vous devez créer un gestionnaire pour cette requête. Dans chaque gestionnaire, la méthode public async Task Handle est le cœur où la logique de la demande est exécutée :

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

Utilisation de MediatR dans votre application

En suivant le même processus que celui utilisé pour configurer MediatR, vous l'intégrez dans le flux de travail de votre application. Cela se fait généralement par l'intermédiaire d'un contrôleur ou d'un point de terminaison dans une application ASP.NET Core. Voici un exemple utilisant un contrôleur 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

Dans ce contrôleur, la méthode d'action Create envoie la CreateUserCommand à MediatR en appelant _mediator.Send(commande). MediatR recherche alors le gestionnaire approprié pour cette commande et l'exécute. Le résultat est renvoyé et utilisé pour générer une réponse dans le même processus.

Au-delà des demandes de base : Notifications et comportements

MediatR prend également en charge les notifications et les comportements. Les notifications sont des messages auxquels plusieurs gestionnaires peuvent s'abonner et qu'ils peuvent traiter, ce qui permet d'adopter une approche davantage axée sur les événements dans votre application. Les comportements, quant à eux, s'apparentent à un intergiciel pour vos requêtes MediatR, vous permettant de mettre en œuvre des préoccupations transversales telles que la journalisation, la validation ou la gestion des transactions.

Introduction de la bibliothèque IronPDF

IronPDF est une bibliothèque C# conçue pour les développeurs .NET qui ont besoin d'un moyen simple de créer, d'éditer et de travailler avec des fichiers PDF dans leurs applications sans avoir à se soucier de l'écriture. Les développeurs peuvent générer des PDF sans avoir recours à des API complexes, en convertissant simplement des pages web ou des fichiers Code HTML directement dans le format PDF. IronPDF ne se limite pas à la création de PDF ; il offre également des fonctions d'édition des PDF, telles que l'ajout de texte, d'images et de pages, ou encore le remplissage et l'édition de formulaires dans les documents PDF. Les développeurs peuvent travailler de manière exhaustive avec les PDF, notamment en effectuant des tâches telles que la fusion, le fractionnement et la sécurisation des fichiers PDF à l'aide de mots de passe et d'autorisations.

Exemple de code

Dans cet exemple, supposons que la requête MediatR se réfère à une forme de contenu médiatique ou de métadonnées que nous voulons inclure dans notre PDF. Comme MediatR n'est pas directement lié à la fonctionnalité d'IronPDF, nous allons aborder la question en créant un document PDF à partir d'un contenu HTML qui inclut des informations ou des références médiatiques, ce qui constitue un excellent point de départ.

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

Dans cet extrait de code, htmlContent est une variable qui doit contenir vos informations médiatiques au format HTML. Il peut s'agir de texte, d'images, de liens vers des vidéos ou de tout autre contenu compatible HTML. IronPDF convertira ce contenu HTML en un document PDF, en préservant la mise en page et le formatage spécifiés dans le HTML.

Conclusion

En suivant les étapes décrites dans cet article, vous devriez maintenant disposer d'une base solide pour intégrer MediatR dans vos projets, depuis la gestion des commandes et des requêtes de base jusqu'à l'exploitation de fonctionnalités plus avancées telles que les notifications et les comportements. Au fur et à mesure que votre application grandit et évolue, MediatR propose des outils et des modèles qui peuvent vous aider à maintenir votre base de code propre, maintenable et évolutive.

En conclusion, il convient de noter que l'exploration et l'intégration de différentes bibliothèques et de différents outils, tels qu'IronPDF, peuvent contribuer à améliorer vos projets .NET. IronPDF offre un service de essai gratuit. Pour les projets nécessitant des fonctions PDF avancées, la licence d'IronPDF est proposée à partir de 749 $, ce qui en fait une solution robuste pour les développeurs .NET désireux d'étendre les fonctionnalités de leur application.