Oefening: Berichten verzenden en ontvangen van een Service Bus-wachtrij met behulp van .NET.

30 minuten

In deze oefening leert u het volgende:

Maak een Service Bus-naamruimte en -wachtrij met behulp van de Azure CLI.
Maak een .NET-consoletoepassing om berichten uit de wachtrij te verzenden en te ontvangen.

Vereisten

Een Azure-account met een actief abonnement. Als nog geen abonnement hebt, kunt u zich registreren voor een gratis abonnement op https://azure.com/free.
Visual Studio Code op een van de ondersteunde platforms.
De C#-extensie voor Visual Studio Code.
.NET 8 is het doelframework voor de oefening.

In deze sectie opent u de terminal en maakt u enkele variabelen die in de rest van de oefening worden gebruikt om de opdrachtinvoer en het maken van unieke resourcenamen een beetje eenvoudiger te maken.

Start De Azure Cloud Shell en selecteer Bash en de omgeving.
Maak variabelen die worden gebruikt in de Azure CLI-opdrachten. Vervang door <myLocation> een regio bij u in de buurt.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Azure-resources maken

Maak een resourcegroep voor het opslaan van de Azure-resources die u maakt.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Maak een Service Bus-berichtennaamruimte. Met de volgende opdracht maakt u een naamruimte met behulp van de variabele die u eerder hebt gemaakt. Het duurt enkele minuten voordat de bewerking is voltooid.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Een Service Bus-wachtrij maken

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

De verbindingsreeks voor de Service Bus-naamruimte ophalen

Open Azure Portal en navigeer naar de resourcegroep az204-svcbus-rg .
Selecteer de az204svcbus-resource die u hebt gemaakt.
Selecteer Beleid voor gedeelde toegang in de sectie Instellingen en selecteer vervolgens het beleid RootManageSharedAccessKey .
Kopieer de primaire verbindingsreeks uit het dialoogvenster dat wordt geopend en sla deze op in een bestand, of laat de portal open en kopieer de sleutel wanneer dat nodig is.

Console-app maken om berichten naar de wachtrij te verzenden

Open een lokale terminal en maak een map met de naam az204svcbus en voer vervolgens de opdracht uit om Visual Studio Code te starten.
```
code .
```
Open de terminal in Visual Studio Code door Terminal New Terminal te selecteren in de menubalk en voer de volgende opdrachten uit om de console-app te maken en het pakket Azure.Messaging.ServiceBus toe te voegen.>
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
Voeg in Program.cs de volgende using instructies toe boven aan het bestand na de huidige using instructie.
```
using Azure.Messaging.ServiceBus;
```

Voeg de volgende variabelen toe aan de code en stel de connectionString variabele in op de verbindingsreeks die u eerder hebt verkregen.

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

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

Voeg de volgende code toe onder de variabelen die u zojuist hebt toegevoegd. Zie opmerkingen bij de code voor meer informatie.

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

Sla het bestand op en voer de dotnet build opdracht uit om te controleren of er geen fouten zijn.
Voer het programma uit met behulp van de dotnet run opdracht en wacht op het volgende bevestigingsbericht. Druk vervolgens op een willekeurige toets om het programma af te sluiten.
```
A batch of three messages has been published to the queue.
```

Resultaten controleren

Meld u aan bij Azure Portal en navigeer naar uw Service Bus-naamruimte.
Selecteer Wachtrijen in de sectie Entiteiten van het navigatiedeelvenster en selecteer vervolgens de az204-queue in de lijst.
Selecteer Service Bus Explorer in het navigatiedeelvenster van de Service Bus-wachtrij.
Selecteer Weergeven vanaf het begin en de drie berichten die zijn verzonden, worden weergegeven.

Project bijwerken om berichten naar de wachtrij te ontvangen

In deze sectie werkt u het programma bij voor het ontvangen van berichten uit de wachtrij.

Voeg de volgende code toe aan het einde van de bestaande code. Zie opmerkingen bij de code voor meer informatie.

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

Gebruik de dotnet build opdracht om ervoor te zorgen dat er geen fouten zijn.
Gebruik de dotnet run opdracht om de toepassing uit te voeren. Er worden nog drie berichten naar de wachtrij verzonden en vervolgens alle zes berichten opgehaald. Druk op een willekeurige toets om de ontvanger en de toepassing te stoppen.
```
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
```
Notitie

Omdat de toepassing twee batches berichten heeft verzonden voordat deze worden opgehaald, ziet u twee batches van drie berichten die in de uitvoer worden weergegeven.
Ga terug naar de portal en selecteer Opnieuw bekijken vanaf het begin . U ziet dat er geen berichten in de wachtrij worden weergegeven omdat we ze allemaal hebben opgehaald.

Resources opschonen

Wanneer de resources niet meer nodig zijn, kunt u de az group delete opdracht in Azure Cloud Shell gebruiken om de resourcegroep te verwijderen.

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