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

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.

Wichtig

In dieser Schnellstartanleitung wird das neue Paket „Azure.Messaging.ServiceBus“ verwendet.This quickstart uses the new Azure.Messaging.ServiceBus package. Eine Schnellstartanleitung, in der das alte Paket „Microsoft.Azure.ServiceBus“ verwendet wird, finden Sie im Artikel mit den Informationen zum Senden und Empfangen von Ereignissen mit dem Paket „Microsoft.Azure.ServiceBus“.For a quickstart that uses the old Microsoft.Azure.ServiceBus package, see Send and receive events using Microsoft.Azure.ServiceBus package.

VoraussetzungenPrerequisites

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.

    Empfangene Nachrichten mit Anzahl und Größe

    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.

    Aktive Nachrichten und Größe nach dem Empfang

Nächste SchritteNext steps

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