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# (So funktioniert es für Entwickler): 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# (So funktioniert es für Entwickler): 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();
' Initialize a new web application
Dim builder = WebApplication.CreateBuilder(args)

' Add MediatR to the service container
builder.Services.AddMediatR(GetType(Program).Assembly)

' Build the web application
Dim app = builder.Build()
$vbLabelText   $csharpLabel

In der Programmklasse initialisiert var builder = WebApplication.CreateBuilder(args); die Webanwendung und bereitet so die MediatR-Integration 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; }
}
Public Class CreateUserCommand
	Implements IRequest(Of Integer)

	Public Property Name() As String
	Public Property Email() As String
	Public Property Id() As Integer
End Class
$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 Logik der Anfrage in der Methode Handle ausgeführt:

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
    }
}
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 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
	End Function
End Class
$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);
    }
}
<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
$vbLabelText   $csharpLabel

In diesem Controller sendet die Aktionsmethode Create den Befehl 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.

Erweiterte Anfragen: 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# (So funktioniert es für Entwickler): 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");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

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

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

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$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>

                {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>

                {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.");
    }
}
Imports IronPdf

Public Class PdfGenerator
    Public Sub CreatePdfWithMediaInfo(htmlContent As String)
        ' Insert your License Key here if required
        License.LicenseKey = "License-Key"

        ' Initialize the HtmlToPdf renderer
        Dim renderer As New ChromePdfRenderer()

        ' Create an HTML template with media information
        Dim htmlTemplate As String = $"
            <html>
            <head>
                <title>Media Information</title>
            </head>
            <body>
                <h1>Media Details</h1>

                {htmlContent}
            </body>
            </html>"

        ' Convert the HTML string to a PDF document
        Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlTemplate)
        pdfDocument.SaveAs("MediaInformation.pdf")
    End Sub
End Class

Module Program
    Sub Main(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 Module
$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# (So funktioniert es für Entwickler): Abbildung 4 - PDF-Ausgabe

Abschluss

Mediatr C# (So funktioniert es für Entwickler): 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 benötigen, beginnt die Lizenzierung von IronPDF bei $999 und bietet eine robuste Lösung für .NET-Entwickler, die die Funktionalitäten ihrer Anwendung 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 Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

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

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an