Einführung in CQRS

CQRS steht für Command Query Responsibility Segregation. Es ist ein Muster, das sich darauf konzentriert, das Lesen von Daten vom Schreiben zu trennen. Diese Unterscheidung ist aus mehreren Gründen entscheidend. Erstens ermöglicht sie eine flexiblere Optimierung jeder Operation, was die Anwendungsleistung und Skalierbarkeit verbessert. Wenn Sie Befehle (Schreiben) und Abfragen (Lesen) trennen, können Sie sie unabhängig voneinander optimieren.

Zum Beispiel könnte eine komplexe Anwendung schnelle Leseoperationen erfordern, kann aber langsamere Schreiboperationen tolerieren. Durch die Anwendung von CQRS können Entwickler unterschiedliche Datenmodelle für Lese- und Schreibvorgänge verwenden und die Datenschicht an die spezifischen Bedürfnisse jeder Operation anpassen. In diesem Artikel werden wir die Konzepte des CQRS-Musters und die *IronPDF-Bibliothek für .NET-Entwickler erkunden.

Kernkonzepte und Komponenten

Der Kern von CQRS liegt in der Trennung von Befehl- und Abfrageoperationen, die jeweils unterschiedliche Aspekte der Dateninteraktion behandeln. Das Verständnis dieser Komponenten ist entscheidend für die effektive Implementierung des Musters.

• Befehle: Diese sind für die Aktualisierung der Daten zuständig. Befehle verkörpern komplexe Geschäftslogik und können den Zustand der Daten im Datenspeicher ändern, indem sie ohne Rückgabe von Informationen agieren. Befehle übernehmen die ausschließliche Rolle der Bearbeitung von Schreibdatentasks und beeinflussen direkt den Zustand der Anwendung, ohne eine Ausgabe zu liefern. Zum Beispiel sind das Hinzufügen eines neuen Benutzers oder das Aktualisieren der Details eines vorhandenen Produkts Aktionen, die durch Befehle ausgeführt werden.

• Abfragen: Abfragen, die von einem Abfragehandler verwaltet werden, rufen Daten oder Datentransferobjekte ab, ohne den Systemzustand zu verändern. Es sind die Fragen, die Sie zu Ihren Daten stellen. Zum Beispiel sind das Abrufen eines Benutzerprofils oder das Auflisten aller im Lager verfügbaren Produkte Abfragen. Abfragen geben Daten zurück, stellen jedoch sicher, dass sie die Daten oder deren Zustand nicht verändern.

Eines der beliebten Tools zur Implementierung von CQRS in .NET-Anwendungen ist MediatR, eine Bibliothek für das Vermittlermuster. Es hilft, die Kopplung zwischen Komponenten einer Anwendung zu reduzieren und sie indirekt kommunizieren zu lassen. MediatR erleichtert das Handling von Befehlen und Abfragen, indem es zwischen dem Befehl/der Abfrage und deren Handler vermittelt.

Praktische Umsetzung mit ASP.NET Core

Die Implementierung des CQRS-Musters in ASP.NET Core erfordert die Einrichtung Ihres Projekts, um Befehle und Abfragen zu trennen, indem Sie eine Bibliothek wie MediatR verwenden, um zwischen ihnen zu vermitteln. Hier ist eine vereinfachte Übersicht, wie Sie CQRS in Ihrer ASP.NET Core-Anwendung einrichten können.

Schritt 1: Richten Sie Ihre ASP.NET-Anwendung ein

1. Starten Sie Visual Studio und wählen Sie, ein neues Projekt zu erstellen.

2. Suchen Sie nach und wählen Sie den Projekttyp "ASP.NET Core Webanwendung". Drücken Sie Weiter.

   

3. Benennen Sie Ihr Projekt und legen Sie den Speicherort fest. Klicken Sie auf Erstellen.

4. Wählen Sie das Template "Webanwendung (Model-View-Controller)" für ASP.NET Core. Stellen Sie sicher, dass Sie die .NET Core-Version anstreben, die Ihren Anforderungen entspricht. Klicken Sie auf Erstellen.

Schritt 2

Als nächstes möchten Sie Ihr Projekt für CQRS organisieren. Dies können Sie tun, indem Sie Ordner hinzufügen, um Befehle, Abfragen und die gemeinsamen Schnittstellen, die sie verwenden, zu trennen. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt, wählen Sie "Hinzufügen" und dann "Neuer Ordner". Erstellen Sie drei Ordner: "Commands", "Queries" und "Interfaces".

Fügen Sie im Ordner "Interfaces" Schnittstellen für Ihre Befehle und Abfragen hinzu. Für einen Befehl könnten Sie eine Schnittstelle ICommandHandler mit einer Methode Handle haben, die einen Befehl annimmt und die Aktion durchführt. Für eine Abfrage könnten Sie eine Schnittstelle IQueryHandler mit einer Methode Handle haben, die eine Abfrage annimmt und Daten zurückgibt.

Schritt 3

Fügen wir einen Befehl und eine Abfrage zur Demonstration hinzu. Angenommen, Ihre Anwendung verwaltet Aufgaben, und Sie möchten eine Aufgabe hinzufügen (Befehl) und Aufgaben abrufen (Abfrage).

Fügen Sie im Ordner "Interfaces" zwei Schnittstellen hinzu:

// Define interfaces for your handlers:
public interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}

public interface IQueryHandler<TQuery, TResult>
{
    TResult Handle(TQuery query);
}

// Define interfaces for your handlers:
public interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}

public interface IQueryHandler<TQuery, TResult>
{
    TResult Handle(TQuery query);
}

' Define interfaces for your handlers:
Public Interface ICommandHandler(Of TCommand)
	Sub Handle(ByVal command As TCommand)
End Interface

Public Interface IQueryHandler(Of TQuery, TResult)
	Function Handle(ByVal query As TQuery) As TResult
End Interface

' Define interfaces for your handlers:
Public Interface ICommandHandler(Of TCommand)
	Sub Handle(ByVal command As TCommand)
End Interface

Public Interface IQueryHandler(Of TQuery, TResult)
	Function Handle(ByVal query As TQuery) As TResult
End Interface

Fügen Sie im Ordner "Commands" eine Klasse AddItemCommand mit Eigenschaften für die Aufgabendetails hinzu. Fügen Sie auch eine Klasse AddItemCommandHandler hinzu, die ICommandHandler implementiert und die Logik enthält, um eine Aufgabe in die Datenbank hinzuzufügen.

Fügen Sie im Ordner "Queries" eine Klasse GetTasksQuery hinzu, die eine Anfrage für Aufgaben darstellt. Fügen Sie eine weitere Klasse GetTasksQueryHandler hinzu, die IQueryHandler implementiert und die Logik enthält, um Aufgaben aus der Datenbank abzurufen.

Für ein einfaches Beispiel könnte Ihr AddItemCommand so aussehen:

public class AddItemCommand
{
    public string Name { get; set; }
    public int Quantity { get; set; }

    // Constructor
    public AddItemCommand(string name, int quantity)
    {
        Name = name;
        Quantity = quantity;
    }
}

public class AddItemCommand
{
    public string Name { get; set; }
    public int Quantity { get; set; }

    // Constructor
    public AddItemCommand(string name, int quantity)
    {
        Name = name;
        Quantity = quantity;
    }
}

Public Class AddItemCommand
	Public Property Name() As String
	Public Property Quantity() As Integer

	' Constructor
	Public Sub New(ByVal name As String, ByVal quantity As Integer)
		Me.Name = name
		Me.Quantity = quantity
	End Sub
End Class

Public Class AddItemCommand
	Public Property Name() As String
	Public Property Quantity() As Integer

	' Constructor
	Public Sub New(ByVal name As String, ByVal quantity As Integer)
		Me.Name = name
		Me.Quantity = quantity
	End Sub
End Class

Und der AddItemCommandHandler:

public class AddItemCommandHandler : ICommandHandler<AddItemCommand>
{
    public void Handle(AddItemCommand command)
    {
        // Here, you'd add the item to your database, for example, to have employee data stored
        Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}");
        // Add database logic here
    }
}

public class AddItemCommandHandler : ICommandHandler<AddItemCommand>
{
    public void Handle(AddItemCommand command)
    {
        // Here, you'd add the item to your database, for example, to have employee data stored
        Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}");
        // Add database logic here
    }
}

Public Class AddItemCommandHandler
	Implements ICommandHandler(Of AddItemCommand)

	Public Sub Handle(ByVal command As AddItemCommand)
		' Here, you'd add the item to your database, for example, to have employee data stored
		Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}")
		' Add database logic here
	End Sub
End Class

Public Class AddItemCommandHandler
	Implements ICommandHandler(Of AddItemCommand)

	Public Sub Handle(ByVal command As AddItemCommand)
		' Here, you'd add the item to your database, for example, to have employee data stored
		Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}")
		' Add database logic here
	End Sub
End Class

Ihre GetItemsQuery könnte leer sein, wenn sie keine Parameter benötigt, um Aufgaben abzurufen, und GetItemsQueryHandler könnte so aussehen:

public class GetItemsQuery
{
    // This class might not need any properties, depending on your query
}

namespace CQRS_testing.Queries
{
    using CQRS_testing.Interfaces;

    public class GetItemsQueryHandler : IQueryHandler<GetItemsQuery, IEnumerable<string>>
    {
        public IEnumerable<string> Handle(GetItemsQuery query)
        {
            // Here, you'd fetch items from your database
            return new List<string> { "Item1", "Item2" };
        }
    }
}

public class GetItemsQuery
{
    // This class might not need any properties, depending on your query
}

namespace CQRS_testing.Queries
{
    using CQRS_testing.Interfaces;

    public class GetItemsQueryHandler : IQueryHandler<GetItemsQuery, IEnumerable<string>>
    {
        public IEnumerable<string> Handle(GetItemsQuery query)
        {
            // Here, you'd fetch items from your database
            return new List<string> { "Item1", "Item2" };
        }
    }
}

Imports CQRS_testing.Interfaces

Public Class GetItemsQuery
	' This class might not need any properties, depending on your query
End Class

Namespace CQRS_testing.Queries

	Public Class GetItemsQueryHandler
		Implements IQueryHandler(Of GetItemsQuery, IEnumerable(Of String))

		Public Function Handle(ByVal query As GetItemsQuery) As IEnumerable(Of String)
			' Here, you'd fetch items from your database
			Return New List(Of String) From {"Item1", "Item2"}
		End Function
	End Class
End Namespace

Imports CQRS_testing.Interfaces

Public Class GetItemsQuery
	' This class might not need any properties, depending on your query
End Class

Namespace CQRS_testing.Queries

	Public Class GetItemsQueryHandler
		Implements IQueryHandler(Of GetItemsQuery, IEnumerable(Of String))

		Public Function Handle(ByVal query As GetItemsQuery) As IEnumerable(Of String)
			' Here, you'd fetch items from your database
			Return New List(Of String) From {"Item1", "Item2"}
		End Function
	End Class
End Namespace

In Ihren ASP.NET-Controllern verwenden Sie diese Handler, um Befehle und Abfragen zu verarbeiten. Für das Hinzufügen einer Aufgabe würde die Controller-Aktion einen AddTaskCommand erstellen, dessen Eigenschaften aus den Formulardaten übernehmen und dann an eine Instanz von AddTaskCommandHandler übergeben, um die Verarbeitung durchzuführen. Für das Abrufen von Aufgaben würde es einen GetTasksQueryHandler aufrufen, um die Daten zu erhalten und an die Ansicht weiterzuleiten.

Verkabelung in einem Controller

Mit Ihren eingerichteten Befehlen und Abfragen können Sie diese nun in Ihren Controllern verwenden. So könnten Sie dies in einer ItemsController-Klasse tun:

public class ItemsController : Controller
{
    private readonly ICommandHandler<AddItemCommand> _addItemHandler;
    private readonly IQueryHandler<GetItemsQuery, IEnumerable<string>> _getItemsHandler;

    // Constructor injection is correctly utilized here
    public ItemsController(ICommandHandler<AddItemCommand> addItemHandler, IQueryHandler<GetItemsQuery, IEnumerable<string>> getItemsHandler)
    {
        _addItemHandler = addItemHandler;
        _getItemsHandler = getItemsHandler;
    }

    public IActionResult Index()
    {
        // Use the injected _getItemsHandler instead of creating a new instance
        var query = new GetItemsQuery();
        var items = _getItemsHandler.Handle(query);
        return View(items);
    }

    [HttpPost]
    public IActionResult Add(string name, int quantity)
    {
        // Use the injected _addItemHandler instead of creating a new instance
        var command = new AddItemCommand(name, quantity);
        _addItemHandler.Handle(command);
        return RedirectToAction("Index");
    }
}

public class ItemsController : Controller
{
    private readonly ICommandHandler<AddItemCommand> _addItemHandler;
    private readonly IQueryHandler<GetItemsQuery, IEnumerable<string>> _getItemsHandler;

    // Constructor injection is correctly utilized here
    public ItemsController(ICommandHandler<AddItemCommand> addItemHandler, IQueryHandler<GetItemsQuery, IEnumerable<string>> getItemsHandler)
    {
        _addItemHandler = addItemHandler;
        _getItemsHandler = getItemsHandler;
    }

    public IActionResult Index()
    {
        // Use the injected _getItemsHandler instead of creating a new instance
        var query = new GetItemsQuery();
        var items = _getItemsHandler.Handle(query);
        return View(items);
    }

    [HttpPost]
    public IActionResult Add(string name, int quantity)
    {
        // Use the injected _addItemHandler instead of creating a new instance
        var command = new AddItemCommand(name, quantity);
        _addItemHandler.Handle(command);
        return RedirectToAction("Index");
    }
}

Public Class ItemsController
	Inherits Controller

	Private ReadOnly _addItemHandler As ICommandHandler(Of AddItemCommand)
	Private ReadOnly _getItemsHandler As IQueryHandler(Of GetItemsQuery, IEnumerable(Of String))

	' Constructor injection is correctly utilized here
	Public Sub New(ByVal addItemHandler As ICommandHandler(Of AddItemCommand), ByVal getItemsHandler As IQueryHandler(Of GetItemsQuery, IEnumerable(Of String)))
		_addItemHandler = addItemHandler
		_getItemsHandler = getItemsHandler
	End Sub

	Public Function Index() As IActionResult
		' Use the injected _getItemsHandler instead of creating a new instance
		Dim query = New GetItemsQuery()
		Dim items = _getItemsHandler.Handle(query)
		Return View(items)
	End Function

	<HttpPost>
	Public Function Add(ByVal name As String, ByVal quantity As Integer) As IActionResult
		' Use the injected _addItemHandler instead of creating a new instance
		Dim command = New AddItemCommand(name, quantity)
		_addItemHandler.Handle(command)
		Return RedirectToAction("Index")
	End Function
End Class

Public Class ItemsController
	Inherits Controller

	Private ReadOnly _addItemHandler As ICommandHandler(Of AddItemCommand)
	Private ReadOnly _getItemsHandler As IQueryHandler(Of GetItemsQuery, IEnumerable(Of String))

	' Constructor injection is correctly utilized here
	Public Sub New(ByVal addItemHandler As ICommandHandler(Of AddItemCommand), ByVal getItemsHandler As IQueryHandler(Of GetItemsQuery, IEnumerable(Of String)))
		_addItemHandler = addItemHandler
		_getItemsHandler = getItemsHandler
	End Sub

	Public Function Index() As IActionResult
		' Use the injected _getItemsHandler instead of creating a new instance
		Dim query = New GetItemsQuery()
		Dim items = _getItemsHandler.Handle(query)
		Return View(items)
	End Function

	<HttpPost>
	Public Function Add(ByVal name As String, ByVal quantity As Integer) As IActionResult
		' Use the injected _addItemHandler instead of creating a new instance
		Dim command = New AddItemCommand(name, quantity)
		_addItemHandler.Handle(command)
		Return RedirectToAction("Index")
	End Function
End Class

Um alles zu verbinden, besonders wenn Sie Dependency Injection (DI) in ASP.NET Core verwenden, müssen Sie Ihre Befehl- und Abfragehandler mit dem DI-Container in der Startup.cs-Datei registrieren. Auf diese Weise kann ASP.NET Instanzen Ihrer Handler bereitstellen, wenn sie benötigt werden.

Hier ist ein sehr einfaches Beispiel, wie ein Handler registriert wird:

builder.Services.AddTransient<ICommandHandler<AddItemCommand>, AddItemCommandHandler>();
builder.Services.AddTransient<IQueryHandler<GetItemsQuery, IEnumerable<string>>, GetItemsQueryHandler>();

builder.Services.AddTransient<ICommandHandler<AddItemCommand>, AddItemCommandHandler>();
builder.Services.AddTransient<IQueryHandler<GetItemsQuery, IEnumerable<string>>, GetItemsQueryHandler>();

builder.Services.AddTransient(Of ICommandHandler(Of AddItemCommand), AddItemCommandHandler)()
builder.Services.AddTransient(Of IQueryHandler(Of GetItemsQuery, IEnumerable(Of String)), GetItemsQueryHandler)()

builder.Services.AddTransient(Of ICommandHandler(Of AddItemCommand), AddItemCommandHandler)()
builder.Services.AddTransient(Of IQueryHandler(Of GetItemsQuery, IEnumerable(Of String)), GetItemsQueryHandler)()

In der praktischen Anwendung von CQRS ist die Unterscheidung zwischen dem Datenmodel für Schreiboperationen und dem für Leseoperationen grundlegend, um sicherzustellen, dass die Architektur verschiedene und optimierte Ansätze zur Datenverarbeitung unterstützt.

IronPDF: C# PDF-Bibliothek

Erkunden Sie IronPDF für die PDF-Verwaltung ist ein Werkzeug für Entwickler, die mit der C#-Programmiersprache arbeiten, das es ihnen ermöglicht, PDF-Dokumente direkt innerhalb ihrer Anwendungen zu erstellen, zu lesen und zu bearbeiten. Diese Bibliothek ist benutzerfreundlich, was die Integration von PDF-Funktionen wie das Generieren von PDF-Berichten, Rechnungen oder Erstellen von PDFs aus HTML-Code vereinfacht. IronPDF unterstützt verschiedene Funktionen, einschließlich der Bearbeitung von Text und Bildern in PDFs, der Einrichtung von Dokumentsicherheit und der Umwandlung von Webseiten in PDF-Format. Seine Vielseitigkeit und Benutzerfreundlichkeit machen es zu einer wertvollen Ressource für Entwickler, die PDF-Operationen in ihren Projekten implementieren möchten.

IronPDF glänzt mit seiner HTML-zu-PDF-Konvertierungsfähigkeit und behält dabei alle Layouts und Stile bei. Es erstellt PDFs aus Webinhalten, geeignet für Berichte, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können nahtlos in PDFs umgewandelt werden.

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

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

Codebeispiel

Nun, lassen Sie uns erkunden, wie IronPDF in einer C#-Anwendung im Rahmen des Command Query Responsibility Segregation (CQRS)-Musters genutzt werden kann. Unten ist ein vereinfachtes Beispiel, das zeigt, wie Sie IronPDF in einem CQRS-Setup verwenden können, um einen PDF-Bericht zu generieren. Dieses Beispiel ist konzeptionell und konzentriert sich auf die Generierung eines PDF-Dokuments als Befehl.

using IronPdf;
using System.Threading.Tasks;

namespace PdfGenerationApp.Commands
{
    public class GeneratePdfReportCommand
    {
        // Command handler that generates a PDF report
        public async Task GenerateReportAsync(string reportContent, string outputPath)
        {
            // Initialize the IronPDF HTML to PDF renderer
            var renderer = new ChromePdfRenderer();
            // Use IronPDF to generate a PDF from HTML content
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(reportContent));
            // Save the generated PDF to a specified path
            pdf.SaveAs(outputPath);
        }
    }
}

using IronPdf;
using System.Threading.Tasks;

namespace PdfGenerationApp.Commands
{
    public class GeneratePdfReportCommand
    {
        // Command handler that generates a PDF report
        public async Task GenerateReportAsync(string reportContent, string outputPath)
        {
            // Initialize the IronPDF HTML to PDF renderer
            var renderer = new ChromePdfRenderer();
            // Use IronPDF to generate a PDF from HTML content
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(reportContent));
            // Save the generated PDF to a specified path
            pdf.SaveAs(outputPath);
        }
    }
}

Imports IronPdf
Imports System.Threading.Tasks

Namespace PdfGenerationApp.Commands
	Public Class GeneratePdfReportCommand
		' Command handler that generates a PDF report
		Public Async Function GenerateReportAsync(ByVal reportContent As String, ByVal outputPath As String) As Task
			' Initialize the IronPDF HTML to PDF renderer
			Dim renderer = New ChromePdfRenderer()
			' Use IronPDF to generate a PDF from HTML content
			Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(reportContent))
			' Save the generated PDF to a specified path
			pdf.SaveAs(outputPath)
		End Function
	End Class
End Namespace

Imports IronPdf
Imports System.Threading.Tasks

Namespace PdfGenerationApp.Commands
	Public Class GeneratePdfReportCommand
		' Command handler that generates a PDF report
		Public Async Function GenerateReportAsync(ByVal reportContent As String, ByVal outputPath As String) As Task
			' Initialize the IronPDF HTML to PDF renderer
			Dim renderer = New ChromePdfRenderer()
			' Use IronPDF to generate a PDF from HTML content
			Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(reportContent))
			' Save the generated PDF to a specified path
			pdf.SaveAs(outputPath)
		End Function
	End Class
End Namespace

In diesem Beispiel stellt GeneratePdfReportCommand einen Befehl im CQRS-Muster dar. Es beinhaltet eine Methode GenerateReportAsync, die reportContent als HTML-String und einen outputPath entgegennimmt, wo der PDF-Bericht gespeichert wird. Die HtmlToPdf-Klasse von IronPDF wird verwendet, um den HTML-Inhalt in PDF-Format zu konvertieren, welches dann im angegebenen Pfad gespeichert wird. Dieses Setup veranschaulicht, wie Sie die PDF-Generierungsfunktion in die Architektur Ihrer Anwendung integrieren können, insbesondere in Szenarien, die eine klare Trennung der Verantwortlichkeiten erfordern, wie sie von CQRS gefördert werden.

Abschluss

Abschließend bietet das Command Query Responsibility Segregation (CQRS)-Muster einen strukturierten Ansatz zur Trennung der Verantwortlichkeiten von Lese- und Schreiboperationen in Ihren Anwendungen. Diese Trennung klärt nicht nur die Architektur, sondern verbessert auch die Flexibilität, Skalierbarkeit und Leistung Ihrer Systeme. Indem Sie die oben skizzierten Schritte befolgen, können Sie CQRS in Ihren ASP.NET Core-Anwendungen implementieren und Tools wie MediatR verwenden, um die Kommunikation zwischen Befehlen, Abfragen und ihren Handlern zu vereinfachen.

Die Integration von IronPDF in Ihre auf CQRS basierende Anwendung erweitert deren Fähigkeiten weiter und ermöglicht es Ihnen, mühelos PDF-Dokumente zu erstellen, zu manipulieren und zu speichern. Egal, ob Sie Berichte, Rechnungen oder jede Form von Dokumenten erstellen, die umfangreichen Funktionen und die einfache Syntax von IronPDF machen es zu einem leistungsstarken Werkzeug in Ihrem Entwicklungstoolkit. IronPDF bietet eine kostenlose Testversion, die Ihnen die Möglichkeit gibt, seine Fähigkeiten zu erkunden, bevor Sie sich verpflichten. Für die weitere Nutzung beginnen Lizenzen bei $999 und bieten verschiedene Optionen, um den Bedürfnissen Ihres Projekts gerecht zu werden.