Schnellstart: Senden und Empfangen von Nachrichten an bzw. aus Azure Service Bus-Warteschlangen (.NET)

Diese Schnellstartanleitung umfasst folgende Schritte:

1. Erstellen eines Service Bus-Namespace mithilfe des Azure-Portals

2. Erstellen einer Service Bus-Warteschlange mithilfe des Azure-Portals

3. Schreiben einer .NET-Konsolenanwendung, die eine Gruppe von Nachrichten an die Warteschlange sendet

4. Schreiben einer .NET-Konsolenanwendung, die diese Nachrichten aus der Warteschlange empfängt

   Hinweis

   In dieser Schnellstartanleitung wird Schritt für Schritt die Implementierung eines einfachen Szenarios erläutert, bei dem Sie einen Batch von Nachrichten an eine Service Bus-Warteschlange senden und diese Nachrichten empfangen. Eine Übersicht über die .NET-Clientbibliothek finden Sie unter Azure Service Bus-Clientbibliothek für .NET. Weitere Beispiele finden Sie unter Service Bus .NET Beispiele auf GitHub.

Voraussetzungen

Wenn Sie mit dem Dienst noch keine Erfahrung haben, informieren Sie sich über den Abschnitt Was ist Azure Service Bus?, bevor Sie die Schritte in dieser Schnellstartanleitung durchführen.

• Azure-Abonnement. Für die Verwendung von Azure-Diensten benötigen Sie ein Abonnement. Das gilt auch für Azure Service Bus. Wenn Sie nicht über ein Azure-Konto verfügen, können Sie sich für eine kostenlose Testversion registrieren.
• Visual Studio 2022 Die Beispielanwendung nutzt neue Features, die in C# 10 eingeführt wurden. Die Service Bus-Clientbibliothek kann zwar auch mit älteren Versionen von C# verwendet werden, die Syntax unterscheidet sich dann jedoch möglicherweise. Um die neueste Syntax verwenden zu können, empfiehlt es sich, mindestens .NET 6.0 zu installieren und die Sprachversion auf latest festzulegen. Bei Verwendung von Visual Studio sind Versionen vor Visual Studio 2022 nicht mit den Tools kompatibel, die zum Erstellen von C# 10-Projekten erforderlich sind.

Erstellen eines Namespace im Azure-Portal

Um mit der Verwendung von Service Bus-Nachrichtenentitäten in Azure beginnen zu können, müssen Sie zuerst einen Namespace mit einem in Azure eindeutigen Namen erstellen. Ein Namespace ist ein Bereichscontainer für Service Bus-Ressourcen (Warteschlangen, Themen usw.) innerhalb Ihrer Anwendung.

So erstellen Sie einen Namespace

1. Melden Sie sich beim Azure-Portal an.

2. Navigieren Sie zur Seite Alle Dienste.

3. Wählen Sie im linken Navigationsbereich in der Kategorienliste Integration aus, zeigen Sie mit dem Mauszeiger auf Service Bus, und wählen Sie auf der Service Bus-Kachel die Schaltfläche + aus.

   

4. Führen Sie auf der Seite Namespace erstellen auf der Registerkarte Grundlagen die folgenden Schritte aus:

   1. Wählen Sie unter Abonnement ein Azure-Abonnement aus, in dem der Namespace erstellt werden soll.

   2. Wählen Sie unter Ressourcengruppe eine vorhandene Ressourcengruppe für den Namespace aus, oder erstellen Sie eine neue Ressourcengruppe.

   3. Geben Sie einen Namen für den Namespace ein. Der Namespacename sollte den folgenden Namenskonventionen entsprechen:

      • Der Name muss innerhalb von Azure eindeutig sein. Das System überprüft sofort, ob dieser Name verfügbar ist.
      • Die Länge des Namens beträgt mindestens 6 und maximal 50 Zeichen.
      • Der Name darf nur Buchstaben, Zahlen und Bindestriche („-“) enthalten.
      • Der Name muss mit einem Buchstaben beginnen und mit einem Buchstaben oder einer Ziffer enden.
      • Der Name endet nicht mit „-sb“ oder „-mgmt“.

   4. Wählen Sie unter Standort die Region aus, in der Ihr Namespace gehostet werden soll.

   5. Wählen Sie unter Tarif den Tarif (Basic, Standard oder Premium) für den Namespace aus. Wählen Sie für diesen Schnellstart die Option Standard aus.

      Wichtig

      Wenn Sie Themen und Abonnements nutzen möchten, wählen Sie entweder Standard oder Premium aus. Themen/Abonnements werden für den Basic-Tarif nicht unterstützt.

      Wenn Sie den Tarif Premium auswählen, geben Sie die Anzahl von Messagingeinheiten an. Der Premium-Tarif bietet Ressourcenisolierung auf CPU- und Arbeitsspeicherebene, sodass die einzelnen Workloads voneinander isoliert ausgeführt werden. Dieser Ressourcencontainer wird als Messagingeinheit bezeichnet. Ein Premium-Namespace verfügt über mindestens eine Messagingeinheit. Sie können 1, 2, 4, 8 oder 16 Messagingeinheiten für jeden Service Bus Premium-Namespace auswählen. Weitere Informationen finden Sie unter Service Bus Premium- und Standard-Preisstufe für Messaging.

   6. Wählen Sie am unteren Rand der Seite die Option Bewerten + erstellen aus.

      

   7. Überprüfen Sie die Einstellungen auf der Seite Überprüfen und erstellen, und wählen Sie Erstellen aus.

5. Wählen Sie nach der erfolgreichen Bereitstellung der Ressource auf der Bereitstellungsseite Zur Ressource wechseln aus.

   

6. Die Startseite für Ihren Service Bus-Namespace wird angezeigt.

   

Erstellen einer Warteschlange im Azure-Portal

1. Wählen Sie auf der Seite Service Bus-Namespace im linken Navigationsmenü die Option Warteschlangen aus.

2. Wählen Sie auf der Seite Warteschlangen auf der Symbolleiste die Option + Warteschlange aus.

3. Geben Sie einen Namen für die Warteschlange ein, und lassen Sie die anderen Werte unverändert.

4. Wählen Sie jetzt Erstellen.

   

Authentifizieren der App bei Azure

In dieser Schnellstartanleitung werden zwei Möglichkeiten zum Herstellen einer Verbindung mit Azure Service Bus gezeigt: kennwortlos und Verbindungszeichenfolge.

Die erste Option zeigt, wie Sie über Ihren Sicherheitsprinzipal in Microsoft Entra ID und die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) eine Verbindung mit einem Service Bus-Namespace herstellen. Sie müssen sich keine Gedanken darüber machen, dass hartcodierte Verbindungszeichenfolgen in Ihrem Code oder in einer Konfigurationsdatei oder in einem sicheren Speicher wie Azure Key Vault vorhanden sind.

Die zweite Option zeigt, wie Sie mithilfe einer Verbindungszeichenfolge eine Verbindung mit einem Service Bus-Namespace herstellen. Wenn Sie noch nicht mit Azure vertraut sind, ist die Option mit der Verbindungszeichenfolge möglicherweise einfacher. In realen Anwendungen und Produktionsumgebungen wird die kennwortlose Option empfohlen. Weitere Informationen finden Sie unter Authentifizierung und Autorisierung. Weitere Informationen zur kennwortlosen Authentifizierung finden Sie auch auf der Übersichtsseite.

Starten von Visual Studio und Anmelden bei Azure

Der Zugriff auf den Service Bus-Namespace kann mithilfe der folgenden Schritte autorisiert werden:

1. Starten Sie Visual Studio. Wenn das Fenster Erste Schritte angezeigt wird, wählen Sie im rechten Bereich den Link Ohne Code fortfahren aus.

2. Wählen Sie oben rechts in Visual Studio die Schaltfläche Anmelden aus.

   

3. Melden Sie sich mit dem Microsoft Entra-Konto an, dem Sie zuvor eine Rolle zugewiesen haben.

   

Senden von Nachrichten an die Warteschlange

In diesem Abschnitt erfahren Sie, wie Sie eine .NET-Konsolenanwendung zum Senden von Nachrichten an eine Service Bus-Warteschlange erstellen.

Erstellen einer Konsolenanwendung

1. Wählen Sie in Visual Studio Datei ->Neu ->Projekt aus.

2. Führen Sie im Dialogfeld Neues Projekt erstellen die folgenden Schritte aus: Sollte dieses Dialogfeld nicht angezeigt werden, wählen Sie im Menü die Option Datei und anschließend Neu > Projekt aus.

   1. Wählen Sie die Programmiersprache C# aus.

   2. Wählen Sie den Anwendungstyp Konsole aus.

   3. Wählen Sie in der Ergebnisliste Konsolen-App aus.

   4. Wählen Sie anschließend Weiter aus.

      

3. Geben Sie als Projektname QueueSender und als Projektmappenname ServiceBusQueueQuickStart ein, und wählen Sie Weiter aus.

   

4. Wählen Sie auf der Seite Zusätzliche Informationen die Option Erstellen aus, um Projektmappe und Projekt zu erstellen.

Hinzufügen der NuGet-Pakete zum Projekt

Hinzufügen von Code für das Senden von Nachrichten an die Warteschlange

1. Ersetzen Sie den Inhalt von Program.cs durch den folgenden Code. Die wichtigen Schritte sind im folgenden Abschnitt aufgeführt und werden durch zusätzliche Informationen in den Codekommentaren ergänzt.

   • Kennwortlos
   • Verbindungszeichenfolge

   • Erstellt ein Objekt vom Typ ServiceBusClient unter Verwendung des Objekts DefaultAzureCredential. DefaultAzureCredential erkennt automatisch die Anmeldeinformationen Ihrer Visual Studio-Anmeldung für die Authentifizierung bei Azure Service Bus.
   • Ruft die CreateSender-Methode für das ServiceBusClient-Objekt auf, um ein ServiceBusSender-Objekt für die angegebene Service Bus-Warteschlange zu erstellen.
   • Erstellt ein ServiceBusMessageBatch-Objekt mithilfe der ServiceBusSender.CreateMessageBatchAsync-Methode.
   • Hinzufügen von Nachrichten zum Batch mithilfe von ServiceBusMessageBatch.TryAddMessage.
   • Senden des Nachrichtenbatches an die Service Bus-Warteschlange mithilfe der ServiceBusSender.SendMessagesAsync-Methode

   Wichtig

   Geben Sie im Codeschnipsel in die Platzhalterwerte (<NAMESPACE-NAME> und <QUEUE-NAME>) den Namen Ihres Service Bus-Namespaces und Ihrer Service Bus-Warteschlange ein.

   using Azure.Messaging.ServiceBus;
   using Azure.Identity;
   
   // name of your Service Bus queue
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the sender used to publish messages to the queue
   ServiceBusSender sender;
   
   // number of messages to be sent to the queue
   const int numOfMessages = 3;
   
   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Set the transport type to AmqpWebSockets so that the ServiceBusClient uses the port 443. 
   // If you use the default AmqpTcp, ensure that ports 5671 and 5672 are open.
   var clientOptions = new ServiceBusClientOptions
   { 
       TransportType = ServiceBusTransportType.AmqpWebSockets
   };
   //TODO: Replace the "<NAMESPACE-NAME>" and "<QUEUE-NAME>" placeholders.
   client = new ServiceBusClient(
       "<NAMESPACE-NAME>.servicebus.windows.net",
       new DefaultAzureCredential(),
       clientOptions);
   sender = client.CreateSender("<QUEUE-NAME>");
   
   // create a batch 
   using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
   
   for (int i = 1; i <= numOfMessages; i++)
   {
       // try adding a message to the batch
       if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
       {
           // if it is too large for the batch
           throw new Exception($"The message {i} is too large to fit in the batch.");
       }
   }
   
   try
   {
       // Use the producer client to send the batch of messages to the Service Bus queue
       await sender.SendMessagesAsync(messageBatch);
       Console.WriteLine($"A batch of {numOfMessages} messages has been published to the queue.");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await sender.DisposeAsync();
       await client.DisposeAsync();
   }
   
   Console.WriteLine("Press any key to end the application");
   Console.ReadKey();
   

2. Erstellen Sie das Projekt, und vergewissern Sie sich, dass keine Fehler vorhanden sind.

3. Führen Sie das Programm aus, und warten Sie auf die Bestätigungsmeldung.

   A batch of 3 messages has been published to the queue
   

   Wichtig

   In der Regel dauert die Verteilung der Rollenzuweisung in Azure ein bis zwei Minuten. In seltenen Fällen kann es aber bis zu acht Minuten dauern. Wenn bei der ersten Ausführung Ihres Codes Authentifizierungsfehler auftreten, warten Sie einige Momente, und versuchen Sie es dann erneut.

4. Gehen Sie im Azure-Portal wie folgt vor:

   1. Navigieren Sie zu Ihrem Service Bus-Namespace.

   2. Wählen Sie auf der Seite Übersicht die Warteschlange unten im mittleren Bereich aus.

      

   3. Beachten Sie die Werte im Abschnitt Essentials.

      

   Achten Sie auf die folgenden Werte:

   • Unter Anzahl aktiver Nachrichten ist für die Warteschlange nun der Wert 3 angegeben. Jedes Mal, wenn Sie diese Absender-App ausführen, ohne die Nachrichten abzurufen, erhöht sich dieser Wert um 3.
   • Die aktuelle Größe der Warteschlange nimmt jedes Mal inkrementell zu, wenn der Warteschlange durch die App eine Nachricht hinzugefügt wird.
   • Im unteren Abschnitt Metriken im Diagramm Nachrichten können Sie sehen, dass für die Warteschlange drei eingehende Nachrichten vorhanden sind.

Empfangen von Nachrichten aus der Warteschlange

In diesem Abschnitt wird eine .NET-Konsolenanwendung zum Empfangen von Nachrichten aus der Warteschlange erstellt.

Erstellen eines Projekts für den Empfänger

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe ServiceBusQueueQuickStart, zeigen Sie auf Hinzufügen, und wählen Sie anschließend Neues Projekt aus.
2. Wählen Sie zuerst Konsolenanwendung, dann Weiter aus.
3. Geben Sie unter Projektname den Namen QueueReceiver ein, und wählen Sie Erstellen aus.
4. Klicken Sie im Fenster Projektmappen-Explorer mit der rechten Maustaste auf QueueReceiver, und wählen Sie Als Startprojekt festlegen aus.

Hinzufügen der NuGet-Pakete zum Projekt

Hinzufügen von Code für den Empfang von Nachrichten aus der Warteschlange

In diesem Abschnitt fügen Sie Code hinzu, mit dem Nachrichten aus der Warteschlange abgerufen werden.

1. Fügen Sie innerhalb der Klasse Program den folgenden Code hinzu:

   • Kennwortlos
   • Verbindungszeichenfolge

   using System.Threading.Tasks;
   using Azure.Identity;
   using Azure.Messaging.ServiceBus;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the processor that reads and processes messages from the queue
   ServiceBusProcessor processor;
   

2. Fügen Sie am Ende der Klasse Program die folgenden Methoden hinzu:

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

3. Fügen Sie am Ende der Klasse Program den folgenden Code hinzu. Die wichtigen Schritte sind im folgenden Abschnitt aufgeführt und werden durch zusätzliche Informationen in den Codekommentaren ergänzt.

   • Kennwortlos
   • Verbindungszeichenfolge

   • Erstellt ein Objekt vom Typ ServiceBusClient unter Verwendung des Objekts DefaultAzureCredential. DefaultAzureCredential erkennt automatisch die Anmeldeinformationen Ihrer Visual Studio-Anmeldung für die Authentifizierung bei Azure Service Bus.
   • Aufrufen der CreateProcessor-Methode für das ServiceBusClient-Objekt zum Erstellen eines ServiceBusProcessor-Objekts für die angegebene Service Bus-Warteschlange
   • Gibt Handler für die Ereignisse ProcessMessageAsync und ProcessErrorAsync des ServiceBusProcessor-Objekts an.
   • Starten der Verarbeitung von Nachrichten durch Aufrufen von StartProcessingAsync für das ServiceBusProcessor-Objekt
   • Aufrufen von StopProcessingAsync für das ServiceBusProcessor-Objekt, wenn der Benutzer eine Taste zum Beenden der Verarbeitung drückt

   Wichtig

   Geben Sie im Codeschnipsel in die Platzhalterwerte (<NAMESPACE-NAME> und <QUEUE-NAME>) den Namen Ihres Service Bus-Namespaces und Ihrer Service Bus-Warteschlange ein.

   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Set the transport type to AmqpWebSockets so that the ServiceBusClient uses port 443. 
   // If you use the default AmqpTcp, make sure that ports 5671 and 5672 are open.
   
   // TODO: Replace the <NAMESPACE-NAME> placeholder
   var clientOptions = new ServiceBusClientOptions()
   {
       TransportType = ServiceBusTransportType.AmqpWebSockets
   };
   client = new ServiceBusClient(
       "<NAMESPACE-NAME>.servicebus.windows.net",
       new DefaultAzureCredential(),
       clientOptions);
   
   // create a processor that we can use to process the messages
   // TODO: Replace the <QUEUE-NAME> placeholder
   processor = client.CreateProcessor("<QUEUE-NAME>", new ServiceBusProcessorOptions());
   
   try
   {
       // 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");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await processor.DisposeAsync();
       await client.DisposeAsync();
   }
   

4. Die fertige Klasse Program sollte wie folgt aussehen:

   • Kennwortlos
   • Verbindungszeichenfolge

   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   using Azure.Identity;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the processor that reads and processes messages from the queue
   ServiceBusProcessor processor;
   
   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Set the transport type to AmqpWebSockets so that the ServiceBusClient uses port 443.
   // If you use the default AmqpTcp, make sure that ports 5671 and 5672 are open.
   
   // TODO: Replace the <NAMESPACE-NAME> and <QUEUE-NAME> placeholders
   var clientOptions = new ServiceBusClientOptions() 
   {
       TransportType = ServiceBusTransportType.AmqpWebSockets
   };
   client = new ServiceBusClient("<NAMESPACE-NAME>.servicebus.windows.net", 
       new DefaultAzureCredential(), clientOptions);
   
   // create a processor that we can use to process the messages
   // TODO: Replace the <QUEUE-NAME> placeholder
   processor = client.CreateProcessor("<QUEUE-NAME>", new ServiceBusProcessorOptions());
   
   try
   {
       // 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");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await processor.DisposeAsync();
       await client.DisposeAsync();
   }
   
   // handle received messages
   async Task MessageHandler(ProcessMessageEventArgs args)
   {
       string body = args.Message.Body.ToString();
       Console.WriteLine($"Received: {body}");
   
       // complete the message. message is deleted from the queue. 
       await args.CompleteMessageAsync(args.Message);
   }
   
   // handle any errors when receiving messages
   Task ErrorHandler(ProcessErrorEventArgs args)
   {
       Console.WriteLine(args.Exception.ToString());
       return Task.CompletedTask;
   }
   

5. Erstellen Sie das Projekt, und vergewissern Sie sich, dass keine Fehler vorhanden sind.

6. Führen Sie die Empfängeranwendung aus. Nun sollten die empfangenen Nachrichten angezeigt werden. Drücken Sie eine beliebige Taste, um Empfänger und Anwendung zu beenden.

   Wait for a minute and then press any key to end the processing
   Received: Message 1
   Received: Message 2
   Received: Message 3
   
   Stopping the receiver...
   Stopped receiving messages
   

7. Sehen Sie sich erneut die Informationen im Portal an. Warten Sie einige Minuten, und aktualisieren Sie die Seite, wenn für Aktive Nachrichten nicht 0 angezeigt wird.

   • Die Werte für Anzahl aktiver Nachrichten und Aktuelle Größe lauten jetzt 0.

   • Im Diagramm Nachrichten im unteren Abschnitt Metriken können Sie sehen, dass für die Warteschlange drei eingehende und drei ausgehende Nachrichten vorhanden sind.

     

Bereinigen von Ressourcen

Navigieren Sie im Azure-Portal zu Ihrem Service Bus-Namespace, und wählen Sie Löschen im Azure-Portal aus, um den Namespace und die darin enthaltene Warteschlange zu löschen.

Weitere Informationen

Weitere Informationen finden Sie in der folgenden Dokumentation bzw. unter den folgenden Beispielen:

• Azure Service Bus-Clientbibliothek für .NET: Infodatei
• Beispiele bei GitHub
• .NET-API-Referenz
• Erstellen von nachrichtengesteuerten Geschäftsanwendungen mit NServiceBus und Azure Service Bus

Nächste Schritte