Senden und Empfangen von Nachrichten für Azure Service Bus-Warteschlangen (.NET)Send messages to and receive messages from Azure Service Bus queues (.NET)

• 11/13/2020
• 5 Minuten Lesedauer
• • a
  • o
  • O
  • S
  • c

In diesem Tutorial erstellen Sie eine .NET Core-Konsolenanwendung, um Nachrichten für eine Service Bus-Warteschlange zu senden und zu empfangen, indem Sie das Paket Azure.Messaging.ServiceBus verwenden.In this tutorial, you create a .NET Core console application to send messages to and receive messages from a Service Bus queue using the Azure.Messaging.ServiceBus package.

VoraussetzungenPrerequisites

• Visual Studio 2019Visual Studio 2019
• Ein Azure-Abonnement.An Azure subscription. Um dieses Tutorial abzuschließen, benötigen Sie ein Azure-Konto.To complete this tutorial, you need an Azure account. Sie können Ihre MSDN-Abonnentenvorteile aktivieren oder sich für ein kostenloses Konto registrieren.You can activate your MSDN subscriber benefits or sign up for a free account.
• Wenn Sie über keine Warteschlange verfügen, führen Sie die Schritte im Artikel Schnellstart: Erstellen einer Service Bus-Warteschlange mithilfe des Azure-Portals aus, um eine Warteschlange zu erstellen.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. Notieren Sie sich die Verbindungszeichenfolge für Ihren Service Bus-Namespace und den Namen der Warteschlange, die Sie erstellt haben.Note down the connection string for your Service Bus namespace and the name of the queue you created.

Senden von Nachrichten an eine WarteschlangeSend messages to a queue

In dieser Schnellstartanleitung erstellen Sie eine .NET Core-Konsolenanwendung in C#, um Nachrichten an die Warteschlange zu senden.In this quick start, you'll create a C# .NET Core console application to send messages to the queue.

Erstellen einer KonsolenanwendungCreate a console application

Starten Sie Visual Studio, und erstellen Sie ein neues Projekt vom Typ Konsolen-App (.NET Core) für C#.Launch Visual Studio and create a new Console App (.NET Core) project for C#.

Hinzufügen des NuGet-Pakets "Service Bus"Add the Service Bus NuGet package

1. Klicken Sie mit der rechten Maustaste auf das neu erstellte Projekt, und wählen Sie NuGet-Pakete verwalten aus.Right-click the newly created project and select Manage NuGet Packages.
2. Wählen Sie Durchsuchen aus.Select Browse. Suchen Sie nach dem Paket Azure.Messaging.ServiceBus , und wählen Sie es aus.Search for and select Azure.Messaging.ServiceBus.
3. Klicken Sie auf Installieren, um die Installation abzuschließen, und schließen Sie danach den NuGet-Package-Manager.Select Install to complete the installation, then close the NuGet Package Manager.

Hinzufügen von Code für das Senden von Nachrichten an die WarteschlangeAdd code to send messages to the queue

1. Fügen Sie in Program.cs am Beginn der Namespacedefinition die folgenden using-Anweisungen vor der Klassendeklaration hinzu:In Program.cs, add the following using statements at the top of the namespace definition, before the class declaration:

   using System;
   using System.Collections.Generic;
   using System.Threading.Tasks;
   
   using Azure.Messaging.ServiceBus;
   

2. Deklarieren Sie in der Klasse Program die folgenden Variablen:In the Program class, declare the following variables:

       static string connectionString = "<NAMESPACE CONNECTION STRING>";
       static string queueName = "<QUEUE NAME>";
   

   Geben Sie die Verbindungszeichenfolge für den Namespace als connectionString-Variable ein.Enter your connection string for the namespace as the connectionString variable. Geben Sie den Warteschlangennamen ein.Enter your queue name.

3. Fügen Sie direkt nach der Methode Main() die folgende Methode vom Typ SendMessagesAsync() hinzu, um eine Nachricht zu senden:Directly after the Main() method, add the following SendMessagesAsync() method that does the work of sending a message:

       static async Task SendMessageAsync()
       {
           // create a Service Bus client 
           await using (ServiceBusClient client = new ServiceBusClient(connectionString))
           {
               // create a sender for the queue 
               ServiceBusSender sender = client.CreateSender(queueName);
   
               // create a message that we can send
               ServiceBusMessage message = new ServiceBusMessage("Hello world!");
   
               // send the message
               await sender.SendMessageAsync(message);
               Console.WriteLine($"Sent a single message to the queue: {queueName}");
           }
       }
   

4. Fügen Sie eine Methode mit dem Namen CreateMessages hinzu, um eine Warteschlange (.NET-Warteschlange) mit Nachrichten für die Program-Klasse zu erstellen.Add a method named CreateMessages to create a queue (.NET queue) of messages to the Program class. Normalerweise erhalten Sie diese Nachrichten von den verschiedenen Teilen Ihrer Anwendung.Typically, you get these messages from different parts of your application. Hier erstellen wir eine Warteschlange mit Beispielnachrichten.Here, we create a queue of sample messages.

       static Queue<ServiceBusMessage> CreateMessages()
       {
           // create a queue containing the messages and return it to the caller
           Queue<ServiceBusMessage> messages = new Queue<ServiceBusMessage>();
           messages.Enqueue(new ServiceBusMessage("First message in the batch"));
           messages.Enqueue(new ServiceBusMessage("Second message in the batch"));
           messages.Enqueue(new ServiceBusMessage("Third message in the batch"));
           return messages;
       }
   

5. Fügen Sie der Program-Klasse eine Methode mit dem Namen SendMessageBatchAsync und den folgenden Code hinzu.Add a method named SendMessageBatchAsync to the Program class, and add the following code. Bei dieser Methode wird eine Warteschlange mit Nachrichten verwendet, und es werden ein oder mehrere Batches für das Senden an die Service Bus-Warteschlange vorbereitet.This method takes a queue of messages, and prepares one or more batches to send to the Service Bus queue.

       static async Task SendMessageBatchAsync()
       {
           // create a Service Bus client 
           await using (ServiceBusClient client = new ServiceBusClient(connectionString))
           {
               // create a sender for the queue 
               ServiceBusSender sender = client.CreateSender(queueName);
   
               // get the messages to be sent to the Service Bus queue
               Queue<ServiceBusMessage> messages = CreateMessages();
   
               // total number of messages to be sent to the Service Bus queue
               int messageCount = messages.Count;
   
               // while all messages are not sent to the Service Bus queue
               while (messages.Count > 0)
               {
                   // start a new batch 
                   using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
   
                   // add the first message to the batch
                   if (messageBatch.TryAddMessage(messages.Peek()))
                   {
                       // dequeue the message from the .NET queue once the message is added to the batch
                       messages.Dequeue();
                   }
                   else
                   {
                       // if the first message can't fit, then it is too large for the batch
                       throw new Exception($"Message {messageCount - messages.Count} is too large and cannot be sent.");
                   }
   
                   // add as many messages as possible to the current batch
                   while (messages.Count > 0 && messageBatch.TryAddMessage(messages.Peek()))
                   {
                       // dequeue the message from the .NET queue as it has been added to the batch
                       messages.Dequeue();
                   }
   
                   // now, send the batch
                   await sender.SendMessagesAsync(messageBatch);
   
                   // if there are any remaining messages in the .NET queue, the while loop repeats 
               }
   
               Console.WriteLine($"Sent a batch of {messageCount} messages to the topic: {queueName}");
           }
       }
   

6. Ersetzen Sie die Main()-Methode durch die folgende asynchrone Main-Methode.Replace the Main() method with the following async Main method. Hiermit werden die beiden Sendemethoden aufgerufen, um eine einzelne Nachricht und einen Batch mit Nachrichten an die Warteschlange zu senden.It calls both the send methods to send a single message and a batch of messages to the queue.

       static async Task Main()
       {
           // send a message to the queue
           await SendMessageAsync();
   
           // send a batch of messages to the queue
           await SendMessageBatchAsync();
       }
   

7. Führen Sie die Anwendung aus.Run the application. Die unten angegebenen Meldungen sollten angezeigt werden.You should see the following messages.

   Sent a single message to the queue: myqueue
   Sent a batch of messages to the queue: myqueue
   

8. Gehen Sie im Azure-Portal wie folgt vor:In the Azure portal, follow these steps:

   1. Navigieren Sie zu Ihrem Service Bus-Namespace.Navigate to your Service Bus namespace.
   2. Wählen Sie auf der Seite Übersicht die Warteschlange unten im mittleren Bereich aus.On the Overview page, select the queue in the bottom-middle pane.
   3. Beachten Sie die Werte im Abschnitt Essentials.Notice the values in the Essentials section.

   

   Achten Sie auf die folgenden Werte:Notice the following values:

   • Unter Anzahl aktiver Nachrichten ist für die Warteschlange nun der Wert 4 angegeben.The Active message count value for the queue is now 4. Jedes Mal, wenn Sie diese Absender-App ausführen, ohne die Nachrichten abzurufen, erhöht sich dieser Wert um 4.Each time you run this sender app without retrieving the messages, this value increases by 4.
   • Bei der aktuellen Warteschlangengröße erhöht sich der Wert AKTUELL unter Zusammenfassung jeweils, wenn der Warteschlange durch die App Nachrichten hinzugefügt werden.The current size of the queue increments the CURRENT value in Essentials each time the app adds messages to the queue.
   • Im unteren Abschnitt Metriken im Diagramm Nachrichten können Sie sehen, dass für die Warteschlange vier eingehende Nachrichten vorhanden sind.In the Messages chart in the bottom Metrics section, you can see that there are four incoming messages for the queue.

Empfangen von Nachrichten aus einer WarteschlangeReceive messages from a queue

In diesem Abschnitt fügen Sie Code hinzu, mit dem Nachrichten aus der Warteschlange abgerufen werden.In this section, you'll add code to retrieve messages from the queue.

1. Fügen Sie der Program-Klasse die folgenden Methoden hinzu, mit denen Nachrichten und Fehler verarbeitet werden.Add the following methods to the Program class that handle messages and any errors.

       // handle received messages
       static async Task MessageHandler(ProcessMessageEventArgs args)
       {
           string body = args.Message.Body.ToString();
           Console.WriteLine($"Received: {body}");
   
           // complete the message. messages is deleted from the queue. 
           await args.CompleteMessageAsync(args.Message);
       }
   
       // handle any errors when receiving messages
       static Task ErrorHandler(ProcessErrorEventArgs args)
       {
           Console.WriteLine(args.Exception.ToString());
           return Task.CompletedTask;
       }
   

2. Fügen Sie der Program-Klasse eine Methode mit dem Namen ReceiveMessagesAsync und den folgenden Code hinzu, um Nachrichten zu empfangen.Add a method named ReceiveMessagesAsync to the Program class, and add the following code to receive messages.

       static async Task ReceiveMessagesAsync()
       {
           await using (ServiceBusClient client = new ServiceBusClient(connectionString))
           {
               // create a processor that we can use to process the messages
               ServiceBusProcessor processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());
   
               // add handler to process messages
               processor.ProcessMessageAsync += MessageHandler;
   
               // add handler to process any errors
               processor.ProcessErrorAsync += ErrorHandler;
   
               // start processing 
               await processor.StartProcessingAsync();
   
               Console.WriteLine("Wait for a minute and then press any key to end the processing");
               Console.ReadKey();
   
               // stop processing 
               Console.WriteLine("\nStopping the receiver...");
               await processor.StopProcessingAsync();
               Console.WriteLine("Stopped receiving messages");
           }
       }
   

3. Fügen Sie einen Aufruf der ReceiveMessagesAsync-Methode über die Main-Methode hinzu.Add a call to ReceiveMessagesAsync method from the Main method. Kommentieren Sie die SendMessagesAsync-Methode aus, falls Sie nur das Empfangen von Nachrichten testen möchten.Comment out the SendMessagesAsync method if you want to test only receiving of messages. Wenn Sie dies nicht tun, sehen Sie, dass weitere vier Nachrichten an die Warteschlange gesendet werden.If you don't, you see another four messages sent to the queue.

       static async Task Main()
       {
           // send a message to the queue
           await SendMessageAsync();
   
           // send a batch of messages to the queue
           await SendMessageBatchAsync();
   
           // receive message from the queue
           await ReceiveMessagesAsync();
       }
   

Ausführen der AppRun the app

Führen Sie die Anwendung aus.Run the application. Warten Sie eine Minute lang, und drücken Sie dann eine beliebige Taste, um den Empfang von Nachrichten zu beenden.Wait for a minute and then press any key to stop receiving messages. Die folgende Ausgabe sollte angezeigt werden (Leertaste für Schlüssel).You should see the following output (spacebar for the key).

Sent a single message to the queue: myqueue
Sent a batch of messages to the queue: myqueue
Wait for a minute and then press any key to end the processing
Received: Hello world!
Received: First message in the batch
Received: Second message in the batch
Received: Third message in the batch
Received: Hello world!
Received: First message in the batch
Received: Second message in the batch
Received: Third message in the batch

Stopping the receiver...
Stopped receiving messages

Sehen Sie sich erneut die Informationen im Portal an.Check the portal again.

• Die Werte für Anzahl aktiver Nachrichten und AKTUELL lauten jetzt 0.The Active message count and CURRENT values are now 0.

• Im unteren Abschnitt Metriken im Diagramm Nachrichten können Sie sehen, dass für die Warteschlange acht ein- und acht ausgehende Nachrichten vorhanden sind.In the Messages chart in the bottom Metrics section, you can see that there are eight incoming messages and eight outgoing messages for the queue.

  

Nächste SchritteNext steps

Weitere Informationen finden Sie in der folgenden Dokumentation bzw. unter den folgenden Beispielen:See the following documentation and samples:

• Azure Service Bus-Clientbibliothek für .NET: InfodateiAzure Service Bus client library for .NET - Readme
• Beispiele bei GitHubSamples on GitHub
• .NET-API-Referenz.NET API reference