Übung: Senden und Empfangen von Nachrichten aus einer Service Bus-Warteschlange mithilfe von .NET.

30 Minuten

In dieser Übung lernen Sie Folgendes:

Erstellen eines Service Bus-Namespace und einer Warteschlange mithilfe der Azure CLI.
Erstellen einer .NET-Konsolenanwendung, um Nachrichten zu senden und von der Warteschlange zu empfangen

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Wenn Sie noch keines haben, können Sie sich unter https://azure.com/free für eine kostenlose Testversion registrieren.
Visual Studio Code auf einer der unterstützten Plattformen
C#-Erweiterung für Visual Studio Code
.NET 8 ist das Zielframework für diese Übung.

In diesem Abschnitt öffnen Sie Ihr Terminal und erstellen einige Variablen, die Sie während restlichen Übung verwenden, um die Befehlseingabe und die Erstellung eindeutiger Ressourcennamen etwas zu vereinfachen.

Starten Sie die Azure Cloud Shell, und wählen Sie Bash und die Umgebung aus.
Erstellen von Variablen, die in den Azure CLI-Befehlen verwendet werden. Ersetzen Sie <myLocation> durch eine Region in Ihrer Nähe.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Erstellen von Azure-Ressourcen

Erstellen Sie eine Ressourcengruppe für die zu erstellenden Azure-Ressourcen.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Erstellen eines Namespaces für Service Bus-Messaging. Mit dem folgenden Befehl wird ein Namespace mit der zuvor erstellten Variable erstellt. Der Vorgang dauert einige Minuten.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Erstellen einer Service Bus-Warteschlange

az servicebus queue create --resource-group az204-svcbus-rg \
    --namespace-name $myNameSpaceName \
    --name az204-queue

Abrufen der Verbindungszeichenfolge für den Service Bus-Namespace

Öffnen Sie das Azure-Portal, und navigieren Sie zu der Ressourcengruppe az204-svcbus-rg.
Wählen Sie die zuvor erstellte Ressource az204svcbus aus.
Wählen Sie im Abschnitt Einstellungen die Option Richtlinien für gemeinsamen Zugriff und anschließend die Richtlinie RootManageSharedAccessKey aus.
Kopieren Sie die primäre Verbindungszeichenfolge aus dem Dialogfeld, das geöffnet wird, und speichern Sie sie in einer Datei, oder lassen Sie das Portal geöffnet, und kopieren Sie den Schlüssel bei Bedarf.

Erstellen einer Konsolen-App zum Senden von Nachrichten an die Warteschlange

Öffnen Sie ein lokales Terminal, erstellen Sie ein Verzeichnis mit dem Namen az204svcbus, wechseln Sie in dieses Verzeichnis, und führen Sie dann den Befehl zum Starten von Visual Studio Code aus.
```
code .
```
Öffnen Sie das Terminal in Visual Studio Code, indem Sie in der Menüleiste Terminal > Neues Terminal auswählen und die folgenden Befehle ausführen, um die Konsolen-App zu erstellen und das Paket Azure.Messaging.ServiceBus hinzuzufügen.
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
Fügen Sie in program.cs die folgenden using-Anweisungen am Anfang der Datei nach der aktuellen using-Anweisung hinzu.
```
using Azure.Messaging.ServiceBus;
```

Fügen Sie dem Code die folgenden Variablen hinzu, und legen Sie die Variable connectionString auf die zuvor abgerufene Verbindungszeichenfolge fest.

// connection string to your Service Bus namespace
string connectionString = "<CONNECTION STRING>";

// name of your Service Bus topic
string queueName = "az204-queue";

Fügen Sie unter den Variablen, den Sie gerade hinzugefügt haben, den folgenden Code hinzu. Weitere Einzelheiten finden Sie in den Codekommentaren.

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

// Create the clients that we'll use for sending and processing messages.
client = new ServiceBusClient(connectionString);
sender = client.CreateSender(queueName);

// create a batch 
using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();

for (int i = 1; i <= 3; i++)
{
    // try adding a message to the batch
    if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
    {
        // if an exception occurs
        throw new Exception($"Exception {i} has occurred.");
    }
}

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 three 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("Follow the directions in the exercise to review the results in the Azure portal.");
Console.WriteLine("Press any key to continue");
Console.ReadKey();

Speichern Sie die Datei, und führen Sie den Befehl dotnet build aus, um sicherzustellen, dass keine Fehler vorliegen.
Führen Sie das Programm mit dem Befehl dotnet run aus, und warten Sie auf die folgende Bestätigungsmeldung. Drücken Sie dann eine beliebige Taste, um das Programm zu beenden.
```
A batch of three messages has been published to the queue.
```

Überprüfen der Ergebnisse

Melden Sie sich beim Azure-Portal an, und navigieren Sie zu Ihrem Service Bus-Namespace.
Wählen Sie Warteschlange im Abschnitt Entitäten des Navigationsbereichs aus, und wählen Sie dann die az204-Warteschlange aus der Liste aus.
Wählen Sie im Navigationsbereich der Service Bus-Warteschlange das Tool Service Bus Explorer aus.
Wählen Sie Vorschau ab Start aus, um die drei gesendeten Nachrichten anzuzeigen.

Aktualisieren des Projekts zum Empfangen von Nachrichten an die Warteschlange

In diesem Abschnitt aktualisieren Sie das Programm so, dass Nachrichten von der Warteschlange empfangen werden.

Fügen Sie am Ende des vorhandenen Codes folgenden Code hinzu. Weitere Einzelheiten finden Sie in den Codekommentaren.

ServiceBusProcessor processor;
client = new ServiceBusClient(connectionString);

// create a processor that we can use to process the messages
processor = client.CreateProcessor(queueName, 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. messages 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;
}

Verwenden Sie den Befehl dotnet build, um sicherzustellen, dass keine Fehler vorliegen.
Führen Sie die Anwendung mit dem Befehl dotnet run aus. Es werden drei weitere Nachrichten an die Warteschlange gesendet und anschließend alle sechs Nachrichten abgerufen. 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
Received: Message 1
Received: Message 2
Received: Message 3

Stopping the receiver...
Stopped receiving messages
```
Hinweis

Da die Anwendung zwei Batches von Nachrichten gesendet hat, bevor sie sie abruft, sollten in der Ausgabe zwei Batches mit drei Nachrichten dargestellt werden.
Kehren Sie zum Portal zurück, und wählen Sie erneut Vorschau ab Start aus. Beachten Sie, dass keine Nachrichten in der Warteschlange angezeigt werden, da wir sie alle abgerufen haben.

Bereinigen von Ressourcen

Wenn die Ressourcen nicht mehr benötigt werden, können Sie den Befehl az group delete in der Azure Cloud Shell verwenden, um die Ressourcengruppe zu entfernen.

az group delete --name az204-svcbus-rg --no-wait