Prise en main des files d’attente Service BusGet started with Service Bus queues

Dans ce didacticiel, vous créez des applications de console .NET Core pour envoyer des messages à et de recevoir des messages à partir d’une file d’attente Service Bus.In this tutorial, you create .NET Core console applications to send messages to and receive messages from a Service Bus queue.

Conditions préalablesPrerequisites

  1. Visual Studio 2017 Update 3 (version 15.3, 26730.01) ou ultérieur.Visual Studio 2017 Update 3 (version 15.3, 26730.01) or later.
  2. Kit de développement logiciel (SDK) NET Core, version 2.0 ou ultérieure.NET Core SDK, version 2.0 or later.
  3. Un abonnement Azure.An Azure subscription. Pour suivre ce tutoriel, vous avez besoin d’un compte Azure.To complete this tutorial, you need an Azure account. Vous pouvez activer votre avantages pour les abonnés MSDN ou vous inscrire pour un compte gratuit.You can activate your MSDN subscriber benefits or sign up for a free account.
  4. Si vous n’avez pas une file d’attente pour travailler avec, suivez les étapes de la utiliser le portail Azure pour créer une file d’attente Service Bus article pour créer une file d’attente.If you don't have a queue to work with, follow steps in the Use Azure portal to create a Service Bus queue article to create a queue.
    1. Lire le plus rapide pour vue d’ensemble de Service Bus files d’attente.Read the quick overview of Service Bus queues.
    2. Créer un Service Bus espace de noms.Create a Service Bus namespace.
    3. Obtenir le chaîne de connexion.Get the connection string.
    4. Créer un Service Bus file d’attente.Create a Service Bus queue.

Envoyer des messages à la file d’attenteSend messages to the queue

Pour envoyer des messages à la file d’attente, écrivez une application de console C# à l’aide de Visual Studio.To send messages to the queue, write a C# console application using Visual Studio.

Création d’une application consoleCreate a console application

Ouvrez Visual Studio et créez un projet Application de console (.NET Core).Launch Visual Studio and create a new Console App (.NET Core) project.

Ajout du package NuGet Service BusAdd the Service Bus NuGet package

  1. Cliquez avec le bouton droit sur le projet créé et sélectionnez Gérer les packages NuGet.Right-click the newly created project and select Manage NuGet Packages.

  2. Cliquez sur l’onglet Parcourir, recherchez Microsoft.Azure.ServiceBus, puis sélectionnez l’élément Microsoft.Azure.ServiceBus.Click the Browse tab, search for Microsoft.Azure.ServiceBus, and then select the Microsoft.Azure.ServiceBus item. Cliquez sur Installer pour terminer l’installation, puis fermez cette boîte de dialogue.Click Install to complete the installation, then close this dialog box.

    Sélectionner un package NuGet

Écrire du code pour envoyer des messages à la file d’attenteWrite code to send messages to the queue

  1. Dans Program.cs, ajoutez les instructions using suivantes en haut de la définition de l’espace de noms, avant la déclaration de classe :In Program.cs, add the following using statements at the top of the namespace definition, before the class declaration:

    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.ServiceBus;
    
  2. Dans la classe Program, déclarez les variables suivantes.Within the Program class, declare the following variables. Définissez la variable ServiceBusConnectionString sur la chaîne de connexion obtenue lors de la création de l’espace de noms, puis définissez QueueName sur le nom utilisé lors de la création de la file d’attente :Set the ServiceBusConnectionString variable to the connection string that you obtained when creating the namespace, and set QueueName to the name that you used when creating the queue:

    const string ServiceBusConnectionString = "<your_connection_string>";
    const string QueueName = "<your_queue_name>";
    static IQueueClient queueClient;
    
  3. Remplacez le contenu par défaut de Main() par la ligne de code suivante :Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Juste après Main(), ajoutez la méthode MainAsync() asynchrone suivante qui appelle la méthode d’envoi de messages :Directly after Main(), add the following asynchronous MainAsync() method that calls the send messages method:

    static async Task MainAsync()
    {
        const int numberOfMessages = 10;
        queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
        Console.WriteLine("======================================================");
        Console.WriteLine("Press ENTER key to exit after sending all the messages.");
        Console.WriteLine("======================================================");
    
        // Send messages.
        await SendMessagesAsync(numberOfMessages);
    
        Console.ReadKey();
    
        await queueClient.CloseAsync();
    }
    
  5. Juste après la méthode MainAsync(), ajoutez la méthode SendMessagesAsync() suivante qui effectue l’opération d’envoi du nombre de message spécifié par numberOfMessagesToSend (la valeur est actuellement définie sur 10) :Directly after the MainAsync() method, add the following SendMessagesAsync() method that performs the work of sending the number of messages specified by numberOfMessagesToSend (currently set to 10):

    static async Task SendMessagesAsync(int numberOfMessagesToSend)
    {
        try
        {
            for (var i = 0; i < numberOfMessagesToSend; i++)
            {
                // Create a new message to send to the queue.
                string messageBody = $"Message {i}";
                var message = new Message(Encoding.UTF8.GetBytes(messageBody));
    
                // Write the body of the message to the console.
                Console.WriteLine($"Sending message: {messageBody}");
    
                // Send the message to the queue.
                await queueClient.SendAsync(message);
            }
        }
        catch (Exception exception)
        {
            Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
        }
    }
    
  6. Voici à quoi doit ressembler votre fichier Program.cs.Here is what your Program.cs file should look like.

    namespace CoreSenderApp
    {
        using System;
        using System.Text;
        using System.Threading;
        using System.Threading.Tasks;
        using Microsoft.Azure.ServiceBus;
    
        class Program
        {
            // Connection String for the namespace can be obtained from the Azure portal under the 
            // 'Shared Access policies' section.
            const string ServiceBusConnectionString = "<your_connection_string>";
            const string QueueName = "<your_queue_name>";
            static IQueueClient queueClient;
    
            static void Main(string[] args)
            {
                MainAsync().GetAwaiter().GetResult();
            }
    
            static async Task MainAsync()
            {
                const int numberOfMessages = 10;
                queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
                Console.WriteLine("======================================================");
                Console.WriteLine("Press ENTER key to exit after sending all the messages.");
                Console.WriteLine("======================================================");
    
                // Send Messages
                await SendMessagesAsync(numberOfMessages);
    
                Console.ReadKey();
    
                await queueClient.CloseAsync();
            }
    
            static async Task SendMessagesAsync(int numberOfMessagesToSend)
            {
                try
                {
                    for (var i = 0; i < numberOfMessagesToSend; i++)
                    {
                        // Create a new message to send to the queue
                        string messageBody = $"Message {i}";
                        var message = new Message(Encoding.UTF8.GetBytes(messageBody));
    
                        // Write the body of the message to the console
                        Console.WriteLine($"Sending message: {messageBody}");
    
                        // Send the message to the queue
                        await queueClient.SendAsync(message);
                    }
                }
                catch (Exception exception)
                {
                    Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
                }
            }
        }
    }
    
  7. Exécutez le programme et consultez le portail Azure : cliquez sur le nom de votre file d’attente dans la fenêtre Vue d’ensemble de l’espace de noms.Run the program, and check the Azure portal: click the name of your queue in the namespace Overview window. L’écran de file d’attente Fondamentaux est affiché.The queue Essentials screen is displayed. Notez que la valeur Nombre de messages actifs pour la file d’attente doit à présent être de 10.Notice that the Active Message Count value for the queue is now 10. Chaque fois que vous exécutez l’application de l’expéditeur sans récupérer les messages (tel que décrit dans la section suivante), cette valeur augmente de 10.Each time you run the sender application without retrieving the messages (as described in the next section), this value increases by 10. Notez également que la taille actuelle de la file d’attente incrémente la valeur Actuel dans la fenêtre Fondamentaux chaque fois que l’application ajoute des messages à la file d’attente.Also note that the current size of the queue increments the Current value in the Essentials window each time the app adds messages to the queue.

    Taille des messages

Recevoir les messages d'une file d'attenteReceive messages from the queue

Pour recevoir les messages que vous avez envoyé, créez une autre application de console .NET Core et installez le Microsoft.Azure.ServiceBus package NuGet, identique à l’application d’expéditeur précédente.To receive the messages you sent, create another .NET Core console application and install the Microsoft.Azure.ServiceBus NuGet package, similar to the previous sender application.

Écrire du code pour recevoir des messages de la file d’attenteWrite code to receive messages from the queue

  1. Dans Program.cs, ajoutez les instructions using suivantes en haut de la définition de l’espace de noms, avant la déclaration de classe :In Program.cs, add the following using statements at the top of the namespace definition, before the class declaration:

    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.ServiceBus;
    
  2. Dans la classe Program, déclarez les variables suivantes.Within the Program class, declare the following variables. Définissez la variable ServiceBusConnectionString sur la chaîne de connexion obtenue lors de la création de l’espace de noms, puis définissez QueueName sur le nom utilisé lors de la création de la file d’attente :Set the ServiceBusConnectionString variable to the connection string that you obtained when creating the namespace, and set QueueName to the name that you used when creating the queue:

    const string ServiceBusConnectionString = "<your_connection_string>";
    const string QueueName = "<your_queue_name>";
    static IQueueClient queueClient;
    
  3. Remplacez le contenu par défaut de Main() par la ligne de code suivante :Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Juste après Main(), ajoutez la méthode MainAsync() asynchrone suivante qui appelle la méthode RegisterOnMessageHandlerAndReceiveMessages() :Directly after Main(), add the following asynchronous MainAsync() method that calls the RegisterOnMessageHandlerAndReceiveMessages() method:

    static async Task MainAsync()
    {
        queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
        Console.WriteLine("======================================================");
        Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
        Console.WriteLine("======================================================");
    
        // Register the queue message handler and receive messages in a loop
        RegisterOnMessageHandlerAndReceiveMessages();
    
        Console.ReadKey();
    
        await queueClient.CloseAsync();
    }
    
  5. Juste après la méthode MainAsync(), ajoutez la méthode suivante qui enregistre le gestionnaire de messages et reçoit les messages envoyés par l’application d’expéditeur :Directly after the MainAsync() method, add the following method that registers the message handler and receives the messages sent by the sender application:

    static void RegisterOnMessageHandlerAndReceiveMessages()
    {
        // Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
        var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
        {
            // Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
            // Set it according to how many messages the application wants to process in parallel.
            MaxConcurrentCalls = 1,
    
            // Indicates whether the message pump should automatically complete the messages after returning from user callback.
            // False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync().
            AutoComplete = false
        };
    
        // Register the function that processes messages.
        queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
    }
    
  6. Juste après la méthode précédente, ajoutez la méthode ProcessMessagesAsync() suivante pour traiter les messages reçus :Directly after the previous method, add the following ProcessMessagesAsync() method to process the received messages:

    static async Task ProcessMessagesAsync(Message message, CancellationToken token)
    {
        // Process the message.
        Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
    
        // Complete the message so that it is not received again.
        // This can be done only if the queue Client is created in ReceiveMode.PeekLock mode (which is the default).
        await queueClient.CompleteAsync(message.SystemProperties.LockToken);
    
        // Note: Use the cancellationToken passed as necessary to determine if the queueClient has already been closed.
        // If queueClient has already been closed, you can choose to not call CompleteAsync() or AbandonAsync() etc.
        // to avoid unnecessary exceptions.
    }
    
  7. Enfin, ajoutez la méthode suivante pour gérer les exceptions qui peuvent se produire :Finally, add the following method to handle any exceptions that might occur:

    // Use this handler to examine the exceptions received on the message pump.
    static Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)
    {
        Console.WriteLine($"Message handler encountered an exception {exceptionReceivedEventArgs.Exception}.");
        var context = exceptionReceivedEventArgs.ExceptionReceivedContext;
        Console.WriteLine("Exception context for troubleshooting:");
        Console.WriteLine($"- Endpoint: {context.Endpoint}");
        Console.WriteLine($"- Entity Path: {context.EntityPath}");
        Console.WriteLine($"- Executing Action: {context.Action}");
        return Task.CompletedTask;
    }    
    
  8. Voici à quoi doit ressembler votre fichier Program.cs :Here is what your Program.cs file should look like:

    namespace CoreReceiverApp
    {
        using System;
        using System.Text;
        using System.Threading;
        using System.Threading.Tasks;
        using Microsoft.Azure.ServiceBus;
    
        class Program
        {
            // Connection String for the namespace can be obtained from the Azure portal under the 
            // 'Shared Access policies' section.
            const string ServiceBusConnectionString = "<your_connection_string>";
            const string QueueName = "<your_queue_name>";
            static IQueueClient queueClient;
    
            static void Main(string[] args)
            {
                MainAsync().GetAwaiter().GetResult();
            }
    
            static async Task MainAsync()
            {
                queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
                Console.WriteLine("======================================================");
                Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
                Console.WriteLine("======================================================");
    
                // Register QueueClient's MessageHandler and receive messages in a loop
                RegisterOnMessageHandlerAndReceiveMessages();
    
                Console.ReadKey();
    
                await queueClient.CloseAsync();
            }
    
            static void RegisterOnMessageHandlerAndReceiveMessages()
            {
                // Configure the MessageHandler Options in terms of exception handling, number of concurrent messages to deliver etc.
                var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
                {
                    // Maximum number of Concurrent calls to the callback `ProcessMessagesAsync`, set to 1 for simplicity.
                    // Set it according to how many messages the application wants to process in parallel.
                    MaxConcurrentCalls = 1,
    
                    // Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
                    // False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
                    AutoComplete = false
                };
    
                // Register the function that will process messages
                queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
            }
    
            static async Task ProcessMessagesAsync(Message message, CancellationToken token)
            {
                // Process the message
                Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
    
                // Complete the message so that it is not received again.
                // This can be done only if the queueClient is created in ReceiveMode.PeekLock mode (which is default).
                await queueClient.CompleteAsync(message.SystemProperties.LockToken);
    
                // Note: Use the cancellationToken passed as necessary to determine if the queueClient has already been closed.
                // If queueClient has already been Closed, you may chose to not call CompleteAsync() or AbandonAsync() etc. calls 
               // to avoid unnecessary exceptions.
            }
    
            static Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)
            {
                Console.WriteLine($"Message handler encountered an exception {exceptionReceivedEventArgs.Exception}.");
                var context = exceptionReceivedEventArgs.ExceptionReceivedContext;
                Console.WriteLine("Exception context for troubleshooting:");
                Console.WriteLine($"- Endpoint: {context.Endpoint}");
                Console.WriteLine($"- Entity Path: {context.EntityPath}");
                Console.WriteLine($"- Executing Action: {context.Action}");
                return Task.CompletedTask;
            }
        }
    }
    
  9. Réexécutez le programme et vérifiez le portail.Run the program, and check the portal again. Notez que les valeurs Nombre de messages actifs et Actuel sont à présent de 0.Notice that the Active Message Count and Current values are now 0.

    Longueur de la file d’attente

Félicitations !Congratulations! Vous avez maintenant créé une file d’attente, envoyé un ensemble de messages à cette dernière et reçu ces messages de la même file d’attente.You have now created a queue, sent a set of messages to that queue, and received those messages from the same queue.

Étapes suivantesNext steps

Consultez les référentiels GitHub accompagnés d’exemples qui illustrent certaines des fonctionnalités les plus avancées de la messagerie Service Bus.Check out our GitHub repository with samples that demonstrate some of the more advanced features of Service Bus messaging.