Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. mediatr-csharp
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

MediatR ist eine beliebte .NET-Bibliothek, die das Mediator-Muster implementiert und es Objekten ermöglicht, über einen Mediator miteinander zu kommunizieren, anstatt direkt. Dieser Ansatz ist besonders nützlich in Anwendungen, in denen eine geringe Kopplung zwischen den Komponenten wünschenswert ist. In diesem Artikel werfen wir einen detaillierten Blick auf MediatR im Kontext der C#-Entwicklung und geben praktische Beispiele und Anleitungen zur Integration in Ihre Webanwendungsprojekte. Wir werden auch die IronPDF-Bibliothek für PDF-Funktionalitäten in .NET-Anwendungen für die Integration von PDF-Funktionalitäten in ASP.NET Core-Projekten erkunden.

Einführung in das Mediator-Muster und MediatR

Mediatr C# (Wie es für Entwickler funktioniert): Abbildung 1 - MediatR und Mediator-Muster

Das Mediator-Muster ist ein Software-Designmuster, das die Interaktion zwischen Objekten so erleichtert, dass direkte Abhängigkeiten zwischen ihnen reduziert werden, was die lose Kopplung fördert. MediatR bietet eine unanspruchsvolle Mediator-Implementierung, die sich auf Einfachheit und Effizienz bei der Erleichterung der Objektkommunikation konzentriert.

Im Herzen der MediatR-Bibliothek steht das Konzept von Anfragen und mehreren Handlern. An der Anforderungsstelle kapselt ein Objekt die Details des Vorgangs oder der Aktion ein und wartet auf die Bearbeitung 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 zur Implementierung des Command Query Responsibility Segregation (CQRS)-Musters, bei dem die Trennung von Lese- und Schreiboperationen zu besser wartbaren und skalierbaren Softwarearchitekturen führen kann.

Installation von MediatR in einem .NET Core Projekt mit der Package Manager Console

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

Install-Package MediatR

Mediatr C# (Wie es für Entwickler funktioniert): Abbildung 2 - MediatR installieren

Nach der Installation des Pakets ist es notwendig, MediatR in den ASP.NET Core-Abhängigkeitsinjektionscontainer hinzuzufügen. Dies wird normalerweise in der Program.cs oder Startup.cs-Datei Ihres Webanwendungsprojekts durchgeführt, abhängig von der Version von ASP.NET Core, die Sie verwenden. Hier erfahren Sie, wie Sie es in einem Programm mit einer minimalen API-Präsentationsschicht tun können.

// Initialize a new web application
var builder = WebApplication.CreateBuilder(args);

// Add MediatR to the service container
builder.Services.AddMediatR(typeof(Program).Assembly);

// Build the web application
var app = builder.Build();
// Initialize a new web application
var builder = WebApplication.CreateBuilder(args);

// Add MediatR to the service container
builder.Services.AddMediatR(typeof(Program).Assembly);

// Build the web application
var app = builder.Build();
$vbLabelText   $csharpLabel

In der Program-Klasse initialisiert var builder = WebApplication.CreateBuilder(args); die Webanwendung und bereitet die Integration von MediatR vor.

Erstellung Ihrer ersten MediatR-Anfrage und -Handler

MediatR-Anfragen sind einfache Klassen, die die Daten darstellen, die erforderlich sind, um einen bestimmten Vorgang auszuführen. Hier ist ein Beispiel für eine Anfragenklasse, die einen Befehl zum Erstellen 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; }
}
$vbLabelText   $csharpLabel

In diesem Beispiel implementiert die CreateUserCommand-Klasse das IRequest-Interface, was anzeigt, dass diese Anfrage eine Ganzzahl-Antwort erwartet, die die ID des erstellten Benutzers darstellen könnte.

Als nächstes müssen Sie einen Handler für diese Anfrage erstellen. Innerhalb jedes Handlers wird die Handle-Methode ausgeführt, wo 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 a 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 a 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
    }
}
$vbLabelText   $csharpLabel

Verwendung von MediatR in Ihrer Anwendung

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

[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);
    }
}
$vbLabelText   $csharpLabel

In diesem Controller sendet die Create-Aktionsmethode den CreateUserCommand an MediatR, indem sie _mediator.Send(command) aufruft. MediatR findet dann den entsprechenden Handler für diesen Befehl und führt ihn aus. Das Ergebnis wird zurückgegeben und im selben Prozess verwendet, um eine Antwort zu generieren.

Beyond Basic Requests: 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 innerhalb Ihrer Anwendung ermöglicht wird. Verhaltensweisen sind hingegen ähnlich wie Middleware für Ihre MediatR-Anfragen und ermöglichen es Ihnen, Querschnittsbelange wie Protokollierung, Validierung oder Transaktionsmanagement zu implementieren.

Einführung in die IronPDF-Bibliothek

Mediatr C# (Wie es für Entwickler funktioniert): Abbildung 3 - IronPDF

IronPDF ist eine C#-Bibliothek für .NET-Entwickler, die einfach PDFs erstellen, bearbeiten und nutzen wollen. Entwickler können PDFs generieren, ohne sich mit komplexen APIs auseinanderzusetzen, indem sie einfach Webseiten oder HTML-Code direkt in PDF-Format umwandeln. IronPDF ist nicht nur auf die Erstellung von PDFs beschränkt; es bietet auch Funktionen zum Bearbeiten von PDFs, wie das Hinzufügen von Text, Bildern und Seiten oder sogar das Ausfüllen und Bearbeiten von Formularen innerhalb von PDF-Dokumenten. Entwickler können umfassend mit PDFs arbeiten, einschließlich Aufgaben wie dem Zusammenführen, Aufteilen und Sichern von PDF-Dateien mit Passwörtern und Berechtigungen.

IronPDF spezialisiert sich auf das Konvertieren von HTML zu PDF, wobei die ursprünglichen Layouts und Stile präzise erhalten bleiben. Dies macht es ideal zum Generieren von PDFs aus web-basierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Es unterstützt die Konvertierung von HTML-Dateien, URLs und sogar rohen HTML-Strings in PDF-Dateien.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
$vbLabelText   $csharpLabel

Codebeispiel

In diesem Beispiel nehmen wir an, dass sich die MediatR-Anfrage auf eine Art von Medieninhalt oder Metadaten bezieht, die wir in unser PDF einfügen möchten. Da MediatR nicht direkt mit den Funktionen von IronPDF in Zusammenhang steht, nähern wir uns dem, indem wir ein PDF-Dokument aus HTML-Inhalten erstellen, das Medieninformationen oder -verweise als großartigen Ausgangspunkt enthält.

using IronPdf;

public class PdfGenerator
{
    public void CreatePdfWithMediaInfo(string htmlContent)
    {
        // Insert your License Key here if required
        License.LicenseKey = "License-Key";

        // Initialize the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();

        // Create an HTML template with media information
        string htmlTemplate = $@"
            <html>
            <head>
                <title>Media Information</title>
            </head>
            <body>
                <h1>Media Details</h1>
                <!-- Insert your media information here -->
                {htmlContent}
            </body>
            </html>";

        // Convert the HTML string to a PDF document
        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)
    {
        // Insert your License Key here if required
        License.LicenseKey = "License-Key";

        // Initialize the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();

        // Create an HTML template with media information
        string htmlTemplate = $@"
            <html>
            <head>
                <title>Media Information</title>
            </head>
            <body>
                <h1>Media Details</h1>
                <!-- Insert your media information here -->
                {htmlContent}
            </body>
            </html>";

        // Convert the HTML string to a PDF document
        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.");
    }
}
$vbLabelText   $csharpLabel

In diesem Code-Snippet sollte die Variable htmlContent Ihre Medieninformationen im HTML-Format enthalten. Dies könnte Text, Bilder, Links zu Videos oder jeden anderen HTML-kompatiblen Inhalt umfassen. IronPDF konvertiert diesen HTML-Inhalt in ein PDF-Dokument, wobei das im HTML festgelegte Layout und die Formatierung erhalten bleiben.

Mediatr C# (Wie es für Entwickler funktioniert): Abbildung 4 - PDF-Ausgabe

Abschluss

Mediatr C# (Wie es für Entwickler funktioniert): Abbildung 5 - Lizenzierung

Indem Sie die in diesem Artikel beschriebenen Schritte befolgen, sollten Sie nun über eine solide Grundlage für die Integration von MediatR in Ihre Projekte verfügen, beginnend mit der grundlegenden Befehls- und Abfragebearbeitung bis hin zur Nutzung fortschrittlicherer Funktionen wie Benachrichtigungen und Verhaltensweisen. Während Ihre Anwendung wächst und sich weiterentwickelt, bietet MediatR Tools und Muster, die helfen können, Ihren Code sauber, wartbar und skalierbar zu halten.

Zum Abschluss sei darauf hingewiesen, dass die Erkundung und Integration verschiedener Bibliotheken und Tools, wie IronPDF, Ihre .NET-Projekte weiter verbessern kann. IronPDF bietet eine kostenlose Testversion von erweiterten PDF-Funktionen. Für Projekte, die erweiterte PDF-Funktionen erfordern, beginnt die Lizenzierung von IronPDF bei $799, was eine robuste Lösung für .NET-Entwickler darstellt, die die Funktionalitäten ihrer Anwendungen erweitern möchten.

Häufig gestellte Fragen

Wie kann MediatR in ASP.NET Core-Projekte integriert werden?

Um MediatR in ein ASP.NET Core-Projekt zu integrieren, fügen Sie es zum Dependency Injection-Container in Ihrer Program.cs oder Startup.cs-Datei hinzu. Sie können es mit der Package Manager Console mit dem Befehl Install-Package MediatR installieren.

Welche Rolle spielen Anfragen und Handler in MediatR?

In MediatR kapseln Anfragen die Details einer Operation, und Handler verarbeiten diese Anfragen, indem sie die notwendige Geschäftslogik ausführen. Dies unterstützt das Command Query Responsibility Segregation (CQRS)-Muster und erhöht die Wartbarkeit von Anwendungen.

Wie verbessern Benachrichtigungen und Verhalten MediatR?

Benachrichtigungen in MediatR ermöglichen es mehreren Handlern, auf eine einzelne Nachricht zu reagieren, was einen ereignisgesteuerten Ansatz fördert. Verhalten fungieren als Middleware zur Behandlung von Querschnittsbelangen wie Protokollierung, Validierung und Ausnahmebehandlung.

Was sind die Vorteile der Verwendung des Mediator-Musters in .NET-Anwendungen?

Das Mediator-Muster, implementiert durch MediatR, reduziert direkte Abhängigkeiten zwischen Komponenten und fördert eine lose Kopplung. Dies verbessert die Wartbarkeit und Skalierbarkeit von .NET-Anwendungen, indem es den Prinzipien der sauberen Architektur folgt.

Wie kann HTML in .NET-Anwendungen in PDF umgewandelt werden?

IronPDF ermöglicht die Umwandlung von HTML in PDF in .NET-Anwendungen. Sie können die Methode RenderHtmlAsPdf verwenden, um HTML-Strings oder RenderUrlAsPdf für URLs zu konvertieren und sicherzustellen, dass das Layout im resultierenden PDF beibehalten wird.

Welche erweiterten Funktionen bietet IronPDF für die PDF-Verwaltung?

IronPDF bietet erweiterte Funktionen zur PDF-Verwaltung wie das Zusammenführen, Teilen, Bearbeiten von PDFs und das Sichern mit Passwörtern und Berechtigungen. Diese Funktionen eignen sich ideal für Aufgaben wie das Erstellen von Berichten, Rechnungen und anderen Dokumentationen.

Wie unterstützt MediatR das CQRS-Muster?

MediatR unterstützt das CQRS-Muster, indem es die Logik, die Befehlsanfragen verarbeitet, von Abfragen trennt. Diese Trennung ermöglicht einen skalierbareren und wartbareren Code, da jeder Operationstyp unabhängig optimiert und verwaltet werden kann.

Was sind die Vorteile von IronPDF in .NET-Projekten?

IronPDF bietet eine benutzerfreundliche API zum Erstellen, Bearbeiten und Verwalten von PDF-Dateien in .NET-Projekten. Seine Fähigkeit, HTML in PDF umzuwandeln und dabei das Layout beizubehalten, macht es zu einem leistungsstarken Werkzeug zur Erstellung von Berichten und Dokumenten.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen