NServiceBus C# (Comment ça marche pour les développeurs)

Introduction

NServiceBus est un bus de service puissant et adaptable conçu pour le Framework .NET qui rationalise le développement de systèmes distribués. Les modèles de messagerie solides qu'il offre garantissent un traitement et une livraison fiables des messages dans plusieurs microservices et applications. NServiceBus fait abstraction de l'architecture de messagerie sous-jacente, ce qui permet aux développeurs de se concentrer sur la logique commerciale plutôt que sur les subtilités de la construction de systèmes distribués.

En revanche, IronPDF est une bibliothèque .NET très appréciée pour la génération, l'affichage et la modification de fichiers PDF. Il est réputé pour être facile à utiliser et très efficace pour créer des PDF à partir de diverses sources, telles que les fichiers ASPX et HTML.

Les développeurs peuvent construire des systèmes logiciels fiables, évolutifs et faciles à maintenir qui peuvent générer et gérer des documents PDF dans le cadre de leurs opérations commerciales en combinant NServiceBus et IronPDF.

Dans cet article, nous verrons comment mettre en place un simple projet NServiceBus en C# et l'intégrer à IronPDF, afin que vous puissiez créer un flux de travail rationalisé pour la gestion et la production de documents PDF dans une architecture d'application distribuée. Après avoir lu ce tutoriel d'introduction, vous devriez savoir exactement comment ces deux technologies efficaces peuvent coopérer pour simplifier vos tâches liées au format PDF dans un environnement distribué.

Qu'est-ce que NServiceBus C# ?

NServiceBus est un framework puissant et adaptable qui facilite la création de systèmes distribués et d'architectures .NET orientées services. En utilisant NServiceBus, vous pouvez facilement gérer différents types de messages et assurer une communication fiable. Ceci est crucial, en particulier dans une application web et des architectures similaires où l'acheminement et le traitement des messages sont essentiels. Les gestionnaires de messages de NServiceBus gèrent efficacement la réception des messages, en veillant à ce que chaque composant logique interagisse en douceur. NServiceBus présente les caractéristiques importantes suivantes :

Caractéristiques de NServiceBus

Communication par messages

NServiceBus encourage la communication basée sur les messages entre les différents services ou composants d'un système. En découplant les composants, cette méthode permet de créer des conceptions plus faciles à adapter et à gérer.

Une messagerie fiable

En gérant automatiquement les tentatives, les files d'attente de lettres mortes et d'autres techniques de tolérance aux pannes, il garantit une livraison fiable des messages. Dans les systèmes distribués, où les pannes de réseau et autres problèmes de défaillance sont fréquents, cette fiabilité est essentielle.

Modèle de publication et d'abonnement

Le modèle publication/abonnement est pris en charge par NServiceBus, ce qui permet aux services de publier des événements et de laisser d'autres services s'abonner à ces événements. Cela rend possible les architectures pilotées par les événements, dans lesquelles les modifications apportées aux événements dans un composant du système peuvent entraîner des réponses dans d'autres composants.

Saga Management

Les processus commerciaux de longue durée peuvent être gérés avec NServiceBus grâce à son support intégré pour les sagas. Les sagas permettent à la plateforme de services de gérer l'état et de coordonner les opérations complexes entre plusieurs services.

Extensibilité et personnalisation

Il offre un niveau exceptionnel d'extensibilité, permettant aux développeurs de personnaliser la manipulation, le traitement et le processus de transport des messages. Grâce à son adaptabilité, il peut être utilisé dans une grande variété de scénarios.

Intégration avec diverses plates-formes de messagerie

De nombreux systèmes de messagerie, dont MSMQ, RabbitMQ, Azure Service Bus, Amazon SQS et d'autres, peuvent être intégrés à NServiceBus. Les développeurs peuvent ainsi choisir la solution d'infrastructure de communication qui répond le mieux à leurs besoins.

Créer et configurer NServiceBus en C

Vous devez d'abord configurer votre environnement de développement, créer un projet de base et élaborer un service de messagerie et un scénario de base avant de pouvoir commencer à utiliser NServiceBus dans un projet C#. Voici un guide étape par étape pour vous aider à démarrer.

Créer un nouveau projet Visual Studio

Dans Visual Studio, le processus de création d'un projet de console est simple. Suivez ces étapes simples dans l'environnement Visual Studio pour lancer une application console :

Assurez-vous d'avoir installé Visual Studio sur votre PC avant de l'utiliser.

Démarrer un nouveau projet

Cliquez sur Fichier, puis sélectionnez Nouveau, et enfin Projet.

Vous pouvez sélectionner "Console App" ou "Console App"(.NET Core)"La liste des références de modèles de projets ci-dessous vous permet de choisir le modèle de projet qui vous convient le mieux.

Donnez un nom à votre projet dans le champ "Nom".

Choisissez un lieu de stockage pour le projet.

En cliquant sur "Créer", le projet d'application Console démarre.

Installer les paquets NServiceBus

Naviguez vers Outils > NuGet Package Manager > Console du gestionnaire de paquets pour ouvrir la console du gestionnaire de paquets NuGet.

Exécutez la commande suivante pour installer le paquetage NuGet NServiceBus.

Install-Package NServiceBus

Install-Package NServiceBus

IRON VB CONVERTER ERROR developers@ironsoftware.com

Choisir un transport

Le transport est nécessaire à NServiceBus pour recevoir et envoyer des messages. Nous nous en tiendrons au Transport d'apprentissage car il est facile à utiliser et fonctionne bien pour les tests et le développement.

Installez le paquet pour Learning Transport en exécutant.

Install-Package NServiceBus.RabbitMQ

Install-Package NServiceBus.RabbitMQ

IRON VB CONVERTER ERROR developers@ironsoftware.com

Configurer NServiceBus

Configurer le point de terminaison

Définissez la configuration du point de terminaison NServiceBus dans votre fichier Program.cs :

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);
    }
}

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);
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Créer un message

Pour représenter le message, ajoutez une nouvelle classe.

public class MyMessage : IMessage
{
    public string Content { get; set; }
}

public class MyMessage : IMessage
{
    public string Content { get; set; }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Créer un gestionnaire de messages

Pour gérer le message, ajoutez une nouvelle classe.

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;
    }
}

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;
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Envoi d'un message

Envoyer un message à partir du point final. Adaptez votre principal moyen de transmettre un message avec l'aide du maître-chien.

using NServiceBus;
using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
    Console.Title = "Receiver";
    var endpointConfiguration = new EndpointConfiguration("ReceiverEndpoint");
    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);
    }
}

using NServiceBus;
using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
    Console.Title = "Receiver";
    var endpointConfiguration = new EndpointConfiguration("ReceiverEndpoint");
    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);
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Lancez l'application et construisez le projet. La console doit afficher le message "Received message : Bonjour, NServiceBus!"

Pour commencer

Dans un projet C#, l'intégration de NServiceBus avec RabbitMQ et IronPDF implique la configuration des messages entre NServiceBus et RabbitMQ ainsi que l'utilisation d'IronPDF pour créer des PDF. Voici un mode d'emploi complet pour vous aider à démarrer :

Qu'est-ce que IronPDF ?

IronPDF est une bibliothèque .NET conçue pour créer, lire, éditer et convertir des fichiers PDF. Grâce à lui, les programmeurs peuvent travailler avec des fichiers PDF dans des applications C# ou VB.NET avec un outil puissant et intuitif. Les caractéristiques et les capacités d'IronPDF sont décrites en détail ci-dessous :

Caractéristiques d'IronPDF

**Génération de PDF à partir de HTML

Convertissez JavaScript, HTML et CSS en PDF. Prend en charge les requêtes média et la conception réactive, deux normes web contemporaines. Utile pour produire des documents PDF, des factures et des rapports stylisés de manière dynamique à l'aide de HTML et de CSS.

Édition PDF

Ajouter du texte, des images et d'autres éléments à des PDF déjà existants. Extraire du texte et des images de fichiers PDF. Combinez plusieurs PDF en un seul fichier. Diviser des fichiers PDF en plusieurs documents. Inclure des annotations, des pieds de page, des en-têtes et des filigranes.

Conversion PDF

Convertissez Word, Excel, des images et d'autres formats de fichiers en PDF. Conversion de PDF en images(PNG, JPEG, etc.).

Performance et fiabilité

Des performances élevées et une grande fiabilité sont les objectifs de la conception dans les environnements de production. Gestion efficace de documents volumineux.

Installation d'IronPDF

Installez IronPDF en ouvrant la console du gestionnaire de paquets NuGet.

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Configurer l'expéditeur avec le message

Messages est un projet commun(bibliothèque de classe) que l'expéditeur et le destinataire utiliseront tous deux. Définir la classe de message dans le projet Messages. Créez un nouveau projet de bibliothèque de classes appelé Messages et ajoutez-le à la solution.

Définir le message :

Dans le projet Messages, créez une nouvelle classe appelée GeneratePdfMessage.cs :

using NServiceBus;
public class GeneratePdfMessage : IMessage
{
    public string Content { get; set; }
    public string OutputPath { get; set; }
}

using NServiceBus;
public class GeneratePdfMessage : IMessage
{
    public string Content { get; set; }
    public string OutputPath { get; set; }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans les projets de l'expéditeur et du destinataire, incluez une référence au projet Messages.

Configurez le point de terminaison NServiceBus dans le projet Sender pour utiliser RabbitMQ pour la livraison des messages.

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);
    }
}

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);
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Configuration du point de terminaison: le point de terminaison est initialisé avec le nom "SenderEndpoint" en appelant new EndpointConfiguration("SenderEndpoint").

endpointConfiguration est la configuration du transport. En se connectant à une instance locale de RabbitMQ, la méthode UseTransport() configure NServiceBus pour qu'il utilise RabbitMQ comme mécanisme de transport.

Files d'attente d'audit et d'erreur L'endroit où sont envoyés les messages d'échec et les messages traités par l'audit est configuré à l'aide de l'option SendFailedMessagesTo (Envoyer les messages d'échec à)("erreur") et AuditProcessedMessagesTo("audit")respectivement.

Message envoyé: endpointInstance.A GeneratePdfMessage est envoyé au "ReceiverEndpoint" par l'intermédiaire de la fonction Send("ReceiverEndpoint", message) fonction.

Configurer le récepteur pour qu'il génère des PDF

Configurez le point de terminaison NServiceBus dans le projet Receiver pour accepter des messages via RabbitMQ et produire des PDF à l'aide d'IronPDF.

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);
    }
}

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);
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cette configuration, pour le point de réception "ReceiverEndpoint", est comparable à la configuration de l'émetteur.

Gestionnaire de messages

Dans le projet Receiver, créez une nouvelle classe appelée 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;
    }
}

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;
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

GeneratePdfMessage utilisant l'interface IHandleMessages indique qu'il traitera les messages de typeGénérer un message PDF en mettant en œuvre une interface pour IHandleMessages.

Approche de gestion : Après avoir reçu le message, la fonction Handle crée un PDF à l'aide d'IronPDF. Le contenu HTML du message est converti en PDF par le code de rendu HtmlToPdf, qui l'enregistre ensuite dans le chemin de sortie désigné.

Conclusion

NServiceBus peut être intégré à RabbitMQ et IronPDF en C# afin de fournir une solution évolutive et stable pour les systèmes distribués qui doivent générer des PDF de manière dynamique et fiable. Cette combinaison fait appel aux capacités de traitement des messages de NServiceBus, à la fiabilité et à l'adaptabilité de RabbitMQ en tant que courtier de messages, et aux outils d'édition PDF robustes d'IronPDF. Le découplage entre les services est assuré par l'architecture résultante, ce qui permet une évolution et une extensibilité autonomes.

RabbitMQ garantit également la livraison des messages même en cas de défaillance du réseau ou de l'application. NServiceBus simplifie l'acheminement et le traitement des messages, et IronPDF permet de convertir du texte HTML en documents PDF de haute qualité. Cette intégration offre un cadre flexible pour le développement d'applications sophistiquées à grande échelle, tout en améliorant la maintenabilité et la fiabilité du système.

Enfin, en ajoutant IronPDF et Iron Software à votre boîte à outils pour la programmation .NET, vous pouvez travailler efficacement avec des codes-barres, générer des PDF, effectuer des OCR et établir des liens avec Excel. Page des licences d'IronPDFqui commence à 749 $, allie de manière transparente ses caractéristiques aux performances, à la compatibilité et à la facilité d'utilisation duSite officiel d'IronSoftwareafin de fournir des applications et des capacités web supplémentaires et un développement plus efficace.

S'il existe des options de licence bien définies et adaptées aux exigences spécifiques du projet, les développeurs peuvent choisir le modèle optimal en toute confiance. Ces avantages permettent aux développeurs de faire face à toute une série de difficultés de manière efficace et transparente.