NServiceBus ist ein leistungsstarker und anpassungsfähiger Service-Bus, der für das .NET Framework entwickelt wurde und die Entwicklung verteilter Systeme vereinfacht. Die starken Messaging-Muster, die es bietet, garantieren eine zuverlässige Nachrichtenbearbeitung und -übermittlung über mehrere Microservices und Anwendungen hinweg. NServiceBus abstrahiert die zugrundeliegende Messaging-Architektur, sodass Entwickler sich auf die Geschäftslogik konzentrieren können, anstatt auf die Feinheiten des Aufbaus verteilter Systeme.
Im Gegensatz dazu ist IronPDF eine beliebte .NET-Bibliothek zum Erstellen, Anzeigen und Bearbeiten von PDF-Dateien. Sie ist bekannt für ihre Benutzerfreundlichkeit und sehr effizient beim Erstellen von PDFs aus verschiedenen Quellen, wie beispielsweise ASPX-Dateien und HTML.
Entwickler können durch die Kombination von NServiceBus und IronPDF zuverlässige, skalierbare und wartbare Softwaresysteme erstellen, die PDF-Dokumente im Rahmen ihrer Geschäftsprozesse generieren und verwalten können.
Wir werden in diesem Artikel untersuchen, wie man ein einfaches C# NServiceBus-Projekt einrichtet und es mit IronPDF integriert, damit Sie einen nahtlosen Workflow zur Verwaltung und Erstellung von PDF-Dokumenten in einer verteilten Anwendungsarchitektur aufbauen können. Nach dem Lesen dieses Einführungstutorials sollten Sie genau wissen, wie diese zwei effektiven Technologien zusammenarbeiten können, um Ihre PDF-bezogenen Aufgaben in einem verteilten Umfeld zu vereinfachen.
NServiceBus ist ein leistungsstarkes und anpassungsfähiges Framework, das es erleichtert, verteilte Systeme und serviceorientierte .NET-Architekturen zu erstellen. Durch die Nutzung von NServiceBus können Sie problemlos verschiedene Nachrichtentypen verwalten und eine zuverlässige Kommunikation sicherstellen. Dies ist besonders wichtig in einer Webanwendung und ähnlichen Architekturen, in denen nahtloses Nachrichten-Routing und -Verarbeitung entscheidend sind. Die Nachrichtenhandler von NServiceBus sind effektiv im Empfang von Nachrichten und stellen sicher, dass jede logische Komponente reibungslos interagiert. NServiceBus hat die folgenden wichtigen Funktionen:
NServiceBus fördert die nachrichtenbasierte Kommunikation zwischen verschiedenen Diensten oder Komponenten in einem System. Durch das Entkoppeln von Komponenten schafft diese Methode Designs, die einfacher zu skalieren und zu verwalten sind.
Durch die automatische Verwaltung von Wiederholungsversuchen, Dead-Letter-Warteschlangen und anderen Fehlertoleranztechniken wird eine zuverlässige Nachrichtenzustellung garantiert. In verteilten Systemen, in denen Netzwerkausfälle und andere Fehlertypen häufig sind, ist diese Zuverlässigkeit entscheidend.
Das Publish/Subscribe-Muster wird von NServiceBus unterstützt, sodass Dienste Ereignisse veröffentlichen und andere Dienste diese Ereignisse abonnieren können. Dies ermöglicht ereignisgetriebene Architekturen, bei denen Modifikationen an Ereignissen in einer Systemkomponente Reaktionen in anderen Komponenten auslösen können.
Langfristige Geschäftsprozesse können mit NServiceBus dank seiner integrierten Unterstützung für Sagas verwaltet werden. Sagas ermöglichen es der Serviceplattform, den Zustand zu verwalten und komplexe Operationen zwischen mehreren Diensten zu koordinieren.
Es bietet ein außergewöhnliches Maß an Erweiterbarkeit, sodass Entwickler die Handhabung, Verarbeitung und den Transport von Nachrichten personalisieren können. Dank seiner Anpassungsfähigkeit kann es in einer Vielzahl von Szenarien verwendet werden.
Zahlreiche Nachrichtensysteme, einschließlich MSMQ, RabbitMQ, Azure Service Bus, Amazon SQS und andere, können in NServiceBus integriert werden. Dies ermöglicht es Entwicklern, die Kommunikationsinfrastruktur zu wählen, die ihren Anforderungen am besten entspricht.
Sie müssen zunächst Ihre Entwicklungsumgebung einrichten, ein einfaches Projekt erstellen und einen grundlegenden Nachrichtendienst und ein Szenario entwickeln, bevor Sie mit dem Einsatz von NServiceBus in einem C#-Projekt beginnen können. Hier ist eine Schritt-für-Schritt-Anleitung:
In Visual Studio ist der Prozess zur Erstellung eines Konsolenprojekts einfach. Verwenden Sie diese einfachen Schritte in der Visual Studio-Umgebung, um eine Konsolenanwendung zu starten:
Stellen Sie sicher, dass Sie Visual Studio auf Ihrem PC installiert haben, bevor Sie es verwenden.
Klicken Sie auf Datei, dann auf Neu, und schließlich auf Projekt.
Sie können die Vorlage "Konsolen-App" oder "Konsolen-App (.NET Core)" aus der Liste der Projektvorlagenreferenzen unten auswählen.
Geben Sie Ihrem Projekt im Feld "Name" einen Namen.
Wählen Sie einen Speicherort für das Projekt.
Durch Klicken auf "Erstellen" wird das Konsolenanwendungsprojekt gestartet.
Navigieren Sie zu Werkzeuge > NuGet-Paket-Manager > Paket-Manager-Konsole, um die NuGet-Paket-Manager-Konsole zu öffnen.
Führen Sie den folgenden Befehl aus, um das NServiceBus NuGet-Paket zu installieren.
NServiceBus benötigt einen Transport, um Nachrichten zu empfangen und zu senden. Wir werden beim Learning Transport bleiben, da er einfach zu verwenden ist und sich gut für Tests und Entwicklung eignet.
Installieren Sie das Paket für den Learning Transport, indem Sie es ausführen.
Konfigurieren Sie den NServiceBus-Endpunkt in Ihrer Program.cs Datei:
using NServiceBus;
using System;
using System.Threading.Tasks;
using Messages;
class Program
{
static async Task Main()
{
Console.Title = "Sender";
var endpointConfiguration = new EndpointConfiguration("SenderEndpoint");
// Use RabbitMQ Transport
var transport = endpointConfiguration.UseTransport<RabbitMQTransport>();
transport.ConnectionString("host=localhost");
// Set up error queue
endpointConfiguration.SendFailedMessagesTo("error");
// Set up audit queue
endpointConfiguration.AuditProcessedMessagesTo("audit");
// Start the endpoint
var endpointInstance = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
Console.WriteLine("Press Enter to send a message...");
Console.ReadLine();
// Send a message
var message = new MyMessage
{
Content = "Hello, NServiceBus with RabbitMQ!"
};
await endpointInstance.Send("ReceiverEndpoint", message).ConfigureAwait(false);
Console.WriteLine("Message sent. Press Enter to exit...");
Console.ReadLine();
// Stop the endpoint
await endpointInstance.Stop().ConfigureAwait(false);
}
}Imports NServiceBus
Imports System
Imports System.Threading.Tasks
Imports Messages
Class Program
Shared Async Function Main() As Task
Console.Title = "Sender"
Dim endpointConfiguration = New EndpointConfiguration("SenderEndpoint")
' Use RabbitMQ Transport
Dim transport = endpointConfiguration.UseTransport(Of RabbitMQTransport)()
transport.ConnectionString("host=localhost")
' Set up error queue
endpointConfiguration.SendFailedMessagesTo("error")
' Set up audit queue
endpointConfiguration.AuditProcessedMessagesTo("audit")
' Start the endpoint
Dim endpointInstance = Await Endpoint.Start(endpointConfiguration).ConfigureAwait(False)
Console.WriteLine("Press Enter to send a message...")
Console.ReadLine()
' Send a message
Dim message = New MyMessage With {
.Content = "Hello, NServiceBus with RabbitMQ!"
}
Await endpointInstance.Send("ReceiverEndpoint", message).ConfigureAwait(False)
Console.WriteLine("Message sent. Press Enter to exit...")
Console.ReadLine()
' Stop the endpoint
Await endpointInstance.Stop().ConfigureAwait(False)
End Function
End Class
Fügen Sie eine neue Klasse zur Darstellung der Nachricht hinzu.
public class MyMessage : IMessage
{
public string Content { get; set; }
}Public Class MyMessage
Implements IMessage
Public Property Content As String
End ClassFügen Sie eine neue Klasse zur Bearbeitung der Nachricht hinzu.
using NServiceBus;
using System.Threading.Tasks;
public class MyMessageHandler : IHandleMessages<MyMessage>
{
public Task Handle(MyMessage message, IMessageHandlerContext context)
{
Console.WriteLine($"Received message: {message.Content}");
return Task.CompletedTask;
}
}Imports NServiceBus
Imports System.Threading.Tasks
Public Class MyMessageHandler
Implements IHandleMessages(Of MyMessage)
Public Function Handle(ByVal message As MyMessage, ByVal context As IMessageHandlerContext) As Task
Console.WriteLine($"Received message: {message.Content}")
Return Task.CompletedTask
End Function
End ClassSenden Sie eine Nachricht vom Endpunkt. Passen Sie Ihren primären Weg an, um eine Nachricht mit Hilfe des Handlers zu übermitteln.
using NServiceBus;
using System;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
Console.Title = "Receiver";
var endpointConfiguration = new EndpointConfiguration("ReceiverEndpoint");
// Serialization configuration
endpointConfiguration.UseSerialization<NewtonsoftJsonSerializer>();
// Use RabbitMQ Transport
var transport = endpointConfiguration.UseTransport<RabbitMQTransport>();
transport.UseConventionalRoutingTopology(QueueType.Quorum);
transport.ConnectionString("host=localhost");
// Set up error queue
endpointConfiguration.SendFailedMessagesTo("error");
// Set up audit queue
endpointConfiguration.AuditProcessedMessagesTo("audit");
endpointConfiguration.EnableInstallers();
// Start the endpoint
var endpointInstance = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
Console.WriteLine("Press Enter to exit...");
Console.ReadLine();
// Stop the endpoint
await endpointInstance.Stop().ConfigureAwait(false);
}
}Imports NServiceBus
Imports System
Imports System.Threading.Tasks
Module Program
Sub Main()
MainAsync().GetAwaiter().GetResult()
End Sub
Private Async Function MainAsync() As Task
Console.Title = "Receiver"
Dim endpointConfiguration = New EndpointConfiguration("ReceiverEndpoint")
' Serialization configuration
endpointConfiguration.UseSerialization(Of NewtonsoftJsonSerializer)()
' Use RabbitMQ Transport
Dim transport = endpointConfiguration.UseTransport(Of RabbitMQTransport)()
transport.UseConventionalRoutingTopology(QueueType.Quorum)
transport.ConnectionString("host=localhost")
' Set up error queue
endpointConfiguration.SendFailedMessagesTo("error")
' Set up audit queue
endpointConfiguration.AuditProcessedMessagesTo("audit")
endpointConfiguration.EnableInstallers()
' Start the endpoint
Dim endpointInstance = Await Endpoint.Start(endpointConfiguration).ConfigureAwait(False)
Console.WriteLine("Press Enter to exit...")
Console.ReadLine()
' Stop the endpoint
Await endpointInstance.Stop().ConfigureAwait(False)
End Function
End Module
Starten Sie die Anwendung und bauen Sie das Projekt. Die Konsole sollte die Nachricht "Nachricht erhalten: Hallo, NServiceBus!" anzeigen.
In einem C#-Projekt umfasst die Integration von NServiceBus mit RabbitMQ und IronPDF das Konfigurieren von Nachrichten zwischen NServiceBus und RabbitMQ sowie die Verwendung von IronPDF zum Erstellen von PDFs. Hier ist eine umfassende Anleitung:
IronPDF ist eine .NET-Bibliothek, die für das Erstellen, Lesen, Bearbeiten und Konvertieren von PDF-Dateien entwickelt wurde. Damit können Programmierer mit PDF-Dateien in C#- oder VB.NET-Anwendungen mit einem leistungsstarken und intuitiven Tool arbeiten. Die Merkmale und Fähigkeiten von IronPDF werden unten ausführlich beschrieben:
PDF-Erstellung aus HTML
JavaScript, HTML und CSS in PDF konvertieren. Unterstützt Medienabfragen und Responsive Design, zwei moderne Webstandards. Nützlich zum Erstellen dynamisch gestylter PDF-Dokumente, Rechnungen und Berichte mithilfe von HTML und CSS.
PDF-Bearbeitung
Fügen Sie bereits vorhandenen PDFs Text, Bilder und anderes Material hinzu. Text und Bilder aus PDF-Dateien extrahieren. Kombinieren Sie mehrere PDFs zu einer Datei. Teilen Sie PDF-Dateien in mehrere Dokumente auf. Fügen Sie Anmerkungen, Fußzeilen, Kopfzeilen und Wasserzeichen hinzu.
PDF-Konvertierung
Konvertieren Sie Word-, Excel-, Bild- und andere Dateiformate in PDF. PDF in Bildkonvertierung (PNG, JPEG usw.).
Leistung und Zuverlässigkeit
Hohe Leistung und Zuverlässigkeit sind die Designziele in Produktionsumgebungen. Verarbeitet große Dokumente effizient.
Installieren Sie IronPDF, indem Sie die NuGet-Paket-Manager-Konsole öffnen.
Nachrichten ist ein gemeinsames Projekt (Bibliothek), welches sowohl der Sender als auch der Empfänger verwenden werden. Definieren Sie die Nachrichtenklasse im Nachrichtenprojekt. Erstellen Sie ein neues Klassenbibliotheksprojekt namens Nachrichten und fügen Sie es der Lösung hinzu.
Die Nachricht definieren:
Erstellen Sie im Messages-Projekt eine neue Klasse namens GeneratePdfMessage.cs:
using NServiceBus;
public class GeneratePdfMessage : IMessage
{
public string Content { get; set; }
public string OutputPath { get; set; }
}Imports NServiceBus
Public Class GeneratePdfMessage
Implements IMessage
Public Property Content() As String
Public Property OutputPath() As String
End ClassFügen Sie in den Projekten Sender und Empfänger jeweils einen Verweis auf das Nachrichtenprojekt ein.
Richten Sie den NServiceBus-Endpunkt im Senderprojekt ein, um RabbitMQ für die Nachrichtenübermittlung zu verwenden.
using NServiceBus;
using System;
using System.Threading.Tasks;
using Messages;
class Program
{
static async Task Main()
{
Console.Title = "Sender";
var endpointConfiguration = new EndpointConfiguration("SenderEndpoint");
// Use RabbitMQ Transport
var transport = endpointConfiguration.UseTransport<RabbitMQTransport>();
transport.ConnectionString("host=localhost");
// Set up error queue
endpointConfiguration.SendFailedMessagesTo("error");
// Set up audit queue
endpointConfiguration.AuditProcessedMessagesTo("audit");
endpointConfiguration.EnableInstallers();
// Start the endpoint
var endpointInstance = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
Console.WriteLine("Press Enter to send a message...");
Console.ReadLine();
// Send a message
var message = new GeneratePdfMessage
{
Content = "<h1>Hello, NServiceBus with RabbitMQ and IronPDF!</h1>",
OutputPath = "output.pdf"
};
await endpointInstance.Send("ReceiverEndpoint", message).ConfigureAwait(false);
Console.WriteLine("Message sent. Press Enter to exit...");
Console.ReadLine();
// Stop the endpoint
await endpointInstance.Stop().ConfigureAwait(false);
}
}Imports NServiceBus
Imports System
Imports System.Threading.Tasks
Imports Messages
Friend Class Program
Shared Async Function Main() As Task
Console.Title = "Sender"
Dim endpointConfiguration As New EndpointConfiguration("SenderEndpoint")
' Use RabbitMQ Transport
Dim transport = endpointConfiguration.UseTransport(Of RabbitMQTransport)()
transport.ConnectionString("host=localhost")
' Set up error queue
endpointConfiguration.SendFailedMessagesTo("error")
' Set up audit queue
endpointConfiguration.AuditProcessedMessagesTo("audit")
endpointConfiguration.EnableInstallers()
' Start the endpoint
Dim endpointInstance = Await Endpoint.Start(endpointConfiguration).ConfigureAwait(False)
Console.WriteLine("Press Enter to send a message...")
Console.ReadLine()
' Send a message
Dim message = New GeneratePdfMessage With {
.Content = "<h1>Hello, NServiceBus with RabbitMQ and IronPDF!</h1>",
.OutputPath = "output.pdf"
}
Await endpointInstance.Send("ReceiverEndpoint", message).ConfigureAwait(False)
Console.WriteLine("Message sent. Press Enter to exit...")
Console.ReadLine()
' Stop the endpoint
Await endpointInstance.Stop().ConfigureAwait(False)
End Function
End ClassEndpunktkonfiguration: Der Endpunkt wird mit dem Namen "SenderEndpoint" initialisiert, indem new EndpointConfiguration("SenderEndpoint") aufgerufen wird.
endpointConfiguration ist die Transportkonfiguration. Indem er sich mit einer lokalen RabbitMQ-Instanz verbindet, richtet die Methode UseTransport() NServiceBus so ein, dass es RabbitMQ als Transportmechanismus verwendet.
Audit- und Fehlerwarteschlangen: Wohin fehlgeschlagene Nachrichten gesendet und verarbeitete Nachrichten überprüft werden sollen, wird mit SendFailedMessagesTo("error") bzw. AuditProcessedMessagesTo("audit") konfiguriert.
Nachricht gesendet: endpointInstance.Send("ReceiverEndpoint", message) sendet eine GeneratePdfMessage an den "ReceiverEndpoint".
Richten Sie den NServiceBus-Endpunkt im Empfängerprojekt ein, um Nachrichten über RabbitMQ zu akzeptieren und PDFs mit IronPDF zu erzeugen.
using NServiceBus;
using System;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
Console.Title = "Receiver";
var endpointConfiguration = new EndpointConfiguration("ReceiverEndpoint");
// Use RabbitMQ Transport
var transport = endpointConfiguration.UseTransport<RabbitMQTransport>();
transport.ConnectionString("host=localhost");
// Set up error queue
endpointConfiguration.SendFailedMessagesTo("error");
// Set up audit queue
endpointConfiguration.AuditProcessedMessagesTo("audit");
// Start the endpoint
var endpointInstance = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
Console.WriteLine("Press Enter to exit...");
Console.ReadLine();
// Stop the endpoint
await endpointInstance.Stop().ConfigureAwait(false);
}
}Imports NServiceBus
Imports System
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Console.Title = "Receiver"
Dim endpointConfiguration = New EndpointConfiguration("ReceiverEndpoint")
' Use RabbitMQ Transport
Dim transport = endpointConfiguration.UseTransport(Of RabbitMQTransport)()
transport.ConnectionString("host=localhost")
' Set up error queue
endpointConfiguration.SendFailedMessagesTo("error")
' Set up audit queue
endpointConfiguration.AuditProcessedMessagesTo("audit")
' Start the endpoint
Dim endpointInstance = Await Endpoint.Start(endpointConfiguration).ConfigureAwait(False)
Console.WriteLine("Press Enter to exit...")
Console.ReadLine()
' Stop the endpoint
Await endpointInstance.Stop().ConfigureAwait(False)
End Function
End ModuleDieses Setup für den Empfängerendpunkt "ReceiverEndpoint" ist vergleichbar mit der Senderkonfiguration.
Erstellen Sie im Receiver-Projekt eine neue Klasse namens GeneratePdfMessageHandler.cs.
using NServiceBus;
using System;
using System.Threading.Tasks;
using Messages;
using IronPdf;
public class GeneratePdfMessageHandler : IHandleMessages<GeneratePdfMessage>
{
public Task Handle(GeneratePdfMessage message, IMessageHandlerContext context)
{
Console.WriteLine($"Received message to generate PDF with content: {message.Content}");
// Generate PDF
var renderer = new HtmlToPdf();
var pdf = renderer.RenderHtmlAsPdf(message.Content);
pdf.SaveAs(message.OutputPath);
Console.WriteLine($"PDF generated and saved to: {message.OutputPath}");
return Task.CompletedTask;
}
}Imports NServiceBus
Imports System
Imports System.Threading.Tasks
Imports Messages
Imports IronPdf
Public Class GeneratePdfMessageHandler
Implements IHandleMessages(Of GeneratePdfMessage)
Public Function Handle(message As GeneratePdfMessage, context As IMessageHandlerContext) As Task Implements IHandleMessages(Of GeneratePdfMessage).Handle
Console.WriteLine($"Received message to generate PDF with content: {message.Content}")
' Generate PDF
Dim renderer As New HtmlToPdf()
Dim pdf = renderer.RenderHtmlAsPdf(message.Content)
pdf.SaveAs(message.OutputPath)
Console.WriteLine($"PDF generated and saved to: {message.OutputPath}")
Return Task.CompletedTask
End Function
End ClassGeneratePdfMessageHandler verwendet das IHandleMessages Interface, um Nachrichten des Typs GeneratePdfMessage zu verarbeiten.
Handle Methode: Nach dem Empfang der Nachricht erstellt die Handle Funktion ein PDF mit IronPDF. Der HTML-Inhalt in der Nachricht wird durch den HtmlToPdf Renderer-Code in ein PDF umgewandelt, der es dann im vorgesehenen Ausgabepfad speichert.
NServiceBus kann in C# mit RabbitMQ und IronPDF integriert werden, um eine skalierbare und stabile Lösung für verteilte Systeme zu bieten, die PDFs dynamisch und zuverlässig generieren müssen. Diese Kombination nutzt die Fähigkeiten von NServiceBus zur Nachrichtenverarbeitung, die Zuverlässigkeit und Anpassungsfähigkeit von RabbitMQ als Nachrichtenbroker und die robusten PDF-Bearbeitungstools von IronPDF. Die resultierende Architektur sorgt für Entkopplung zwischen Diensten, was eine autonome Entwicklung und Skalierung ermöglicht.
RabbitMQ stellt auch die Nachrichtenübermittlung sicher, selbst im Falle von Netzwerk- oder Anwendungsfehlern. NServiceBus vereinfacht das Routing und die Verarbeitung von Nachrichten, und IronPDF ermöglicht die Umwandlung von HTML-Text in hochwertige PDF-Dokumente. Diese Integration bietet ein flexibles Framework für die Entwicklung anspruchsvoller, groß angelegter Anwendungen und verbessert gleichzeitig die Wartbarkeit und Zuverlässigkeit des Systems.
Letztendlich können Sie, indem Sie IronPDF und Iron Software zu Ihrem Toolkit for .NET-Programmierung hinzufügen, effektiv mit Barcodes arbeiten, PDFs erstellen, OCR durchführen und eine Verbindung mit Excel herstellen. IronPDFs Lizenzierungsseite, die bei $999 beginnt, integriert nahtlos seine Funktionen sowie die Leistung, Kompatibilität und Benutzerfreundlichkeit der flexiblen Suite der offiziellen Website von Iron Software, um zusätzliche Webanwendungen und -fähigkeiten sowie eine effizientere Entwicklung bereitzustellen.
Wenn es klar definierte Lizenzoptionen gibt, die auf die spezifischen Projektanforderungen zugeschnitten sind, können Entwickler mit Zuversicht das optimale Modell auswählen. Diese Vorteile ermöglichen es Entwicklern, eine Vielzahl von Herausforderungen effektiv und transparent zu bewältigen.
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 Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
