Mediatr C# (Wie es für Entwickler funktioniert)

MediatR ist eine beliebte .NET-Bibliothek, die das Mediator-Muster implementiert und es Objekten ermöglicht, nicht direkt, sondern über einen Mediator miteinander zu kommunizieren. Dieser Ansatz ist besonders nützlich bei Anwendungen, bei denen ein geringes Maß an Kopplung zwischen den Komponenten wünschenswert ist. In diesem Artikel werden wir einen detaillierten Blick auf MediatR im Kontext der C#-Entwicklung werfen und praktische Beispiele und Anleitungen für die Integration in Ihre Webanwendungsprojekte geben. Wir erforschen auch die IronPDF-Bibliothek für die Integration von PDF-Funktionen in ASP.NET Core-Projekte.

Einführung in das Mediator-Muster und MediatR

Das Mediator-Muster ist ein Software-Entwurfsmuster, das die Interaktion zwischen Objekten in einer Weise erleichtert, die direkte Abhängigkeiten zwischen ihnen reduziert und eine lose Kopplung fördert. MediatR bietet eine einfache Mediator-Implementierung, die sich auf Einfachheit und Effizienz bei der Erleichterung der Objektkommunikation konzentriert.

Das Herzstück der MediatR-Bibliothek ist das Konzept der Anfragen und mehrerer Handler. Am Anforderungspunkt kapselt ein Objekt die Details der Operation oder Aktion und wartet auf die Verarbeitung durch den MediatR-Mechanismus. Jede Anfrage wird von einem entsprechenden Handler oder einer Handle-Methode bearbeitet, die die Geschäftslogik zur Ausführung der Anfrage enthält. Diese Struktur ist besonders nützlich für die Implementierung der Command Query Responsibility Segregation (CQRS) muster, bei dem die Trennung von Lese- und Schreibvorgängen zu besser wartbaren und skalierbaren Softwarearchitekturen führen kann.

Installation von MediatR in einem .NET Core-Projekt mit der Paketmanager-Konsole

Um MediatR in einem ASP.NET Core-Projekt zu verwenden, müssen Sie zunächst das MediatR-Paket installieren. Dies kann über die Paketmanager-Konsole in Visual Studio mit dem folgenden Befehl erfolgen:

Install-Package MediatR

Nach der Installation des Pakets muss MediatR zum ASP.NET Core Dependency Injection Container hinzugefügt werden. Dies geschieht in der Regel in der Datei Program.cs oder Startup.cs Ihres Webanwendungsprojekts, je nachdem, welche Version von ASP.NET Core Sie verwenden. Hier sehen Sie, wie Sie dies in einem Programm mit einer minimalen API-Präsentationsschicht erreichen können.

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

In der Programmklasse, var builder = WebApplication.CreateBuilder(args); initialisiert die Webanwendung und schafft die Voraussetzungen für die MediatR-Integration.

Erstellen Ihrer ersten MediatR-Anfrage und -Handler

MediatR-Anfragen sind einfache Klassen wie public class emailhandler, die die Daten darstellen, die für die Durchführung einer bestimmten Operation benötigt werden. Hier ist ein Beispiel für eine öffentliche Anforderungsklasse, die einen Befehl zum Anlegen eines neuen Benutzers darstellt.

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

In diesem Beispiel implementiert die Klasse CreateUserCommand die Klasse IRequest Schnittstelle, die angibt, dass diese Anfrage eine ganzzahlige Antwort erwartet, die die ID des erstellten Benutzers darstellen könnte.

Als nächstes müssen Sie einen Handler für diese Anfrage erstellen. In jedem Handler ist die public async Task Handle-Methode der Kern, in dem die Logik der Anfrage ausgeführt wird:

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

Verwendung von MediatR in Ihrer Anwendung

Indem Sie denselben Prozess wie bei der Einrichtung von MediatR befolgen, integrieren Sie es in den Workflow Ihrer Anwendung. Dies geschieht in der Regel über einen Controller oder Endpunkt in einer ASP.NET Core-Anwendung. Hier ist ein Beispiel, das einen API-Controller verwendet:

[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

In diesem Controller sendet die Aktionsmethode Create den Befehl CreateUserCommand an MediatR, indem sie _mediator.Send(befehl). MediatR findet dann den passenden Handler für diesen Befehl und führt ihn aus. Das Ergebnis wird zurückgegeben und zur Erzeugung einer Antwort im selben Prozess verwendet.

Über die Grundanforderungen hinaus: Benachrichtigungen und Verhaltensweisen

MediatR unterstützt auch Benachrichtigungen und Verhaltensweisen. Benachrichtigungen sind Nachrichten, die von mehreren Handlern abonniert und bearbeitet werden können, wodurch ein ereignisorientierterer Ansatz in Ihrer Anwendung ermöglicht wird. Behaviors hingegen sind eine Art Middleware für Ihre MediatR-Anfragen, mit der Sie übergreifende Belange wie Logging, Validierung oder Transaktionsmanagement implementieren können.

Einführung in die IronPDF-Bibliothek

IronPDF ist eine C#-Bibliothek für .NET-Entwickler, die eine unkomplizierte Möglichkeit benötigen, um PDF-Dateien in ihren Anwendungen zu erstellen, zu bearbeiten und mit ihnen zu arbeiten, ohne sich um das Schreiben kümmern zu müssen. Entwickler können PDFs generieren, ohne sich mit komplexen APIs auseinandersetzen zu müssen, indem sie einfach Webseiten oder Dokumente konvertieren HTML-Code direkt im PDF-Format. IronPDF ist nicht nur auf die Erstellung von PDFs beschränkt; es bietet auch Funktionen zur Bearbeitung von PDFs, wie das Hinzufügen von Text, Bildern und Seiten oder das Ausfüllen und Bearbeiten von Formularen in PDF-Dokumenten. Entwickler können umfassend mit PDFs arbeiten, einschließlich Aufgaben wie Zusammenführen, Aufteilen und Sichern von PDF-Dateien mit Passwörtern und Berechtigungen.

Code-Beispiel

In diesem Beispiel gehen wir davon aus, dass sich die MediatR-Anfrage auf eine Form von Medieninhalten oder Metadaten bezieht, die wir in unsere PDF-Datei aufnehmen wollen. Da MediatR nicht direkt mit der Funktionalität von IronPDF zusammenhängt, werden wir uns dem Thema nähern, indem wir ein PDF-Dokument aus einem HTML-Inhalt erstellen, der Medieninformationen oder Referenzen enthält - ein guter Ausgangspunkt.

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

In diesem Codeschnipsel ist htmlContent eine Variable, die Ihre Medieninformationen im HTML-Format enthalten sollte. Das können Texte, Bilder, Links zu Videos oder andere HTML-kompatible Inhalte sein. IronPDF wandelt diesen HTML-Inhalt in ein PDF-Dokument um, wobei das Layout und die Formatierung, die im HTML angegeben sind, beibehalten werden.

Schlussfolgerung

Wenn Sie die in diesem Artikel beschriebenen Schritte befolgen, sollten Sie nun über eine solide Grundlage für die Einbindung von MediatR in Ihre Projekte verfügen, angefangen von der grundlegenden Befehls- und Abfrageverarbeitung bis hin zur Nutzung fortgeschrittener Funktionen wie Benachrichtigungen und Verhaltensweisen. Während Ihre Anwendung wächst und sich weiterentwickelt, bietet MediatR Werkzeuge und Muster, die Ihnen helfen, Ihre Codebasis sauber, wartbar und skalierbar zu halten.

Abschließend ist anzumerken, dass die Erforschung und Integration verschiedener Bibliotheken und Tools, wie IronPDF, Ihre .NET-Projekte weiter verbessern kann. IronPDF bietet eine kostenloser Test. Für Projekte, die erweiterte PDF-Funktionen erfordern, ist IronPDF ab 749 $ lizenziert und bietet eine robuste Lösung für .NET-Entwickler, die die Funktionen ihrer Anwendung erweitern möchten.