Övning: Skicka och ta emot meddelande från en Service Bus-kö med hjälp av .NET.

30 minuter

I den här övningen lär du dig att:

Skapa ett Service Bus-namnområde och en kö med hjälp av Azure CLI.
Skapa ett .NET-konsolprogram för att skicka och ta emot meddelanden från kön.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Om du inte redan har en sådan kan du registrera dig för en kostnadsfri utvärderingsversion på https://azure.com/free.
Visual Studio Code på någon av plattformarna som stöds.
C#-tillägget för Visual Studio Code.
.NET 8 är målramverket för övningen.

I det här avsnittet öppnar du terminalen och skapar några variabler som används under resten av övningen för att göra kommandoposten och skapandet av unika resursnamn lite enklare.

Starta Azure Cloud Shell och välj Bash och miljön.
Skapa variabler som används i Azure CLI-kommandona. Ersätt <myLocation> med en region nära dig.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Skapa Azure-resurser

Skapa en resursgrupp som innehåller de Azure-resurser som du skapar.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Skapa ett namnområde för Service Bus-meddelanden. Följande kommando skapar ett namnområde med hjälp av variabeln som du skapade tidigare. Det tar några minuter att slutföra åtgärden.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Skapa en Service Bus-kö

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

Hämta anslutningssträng för Service Bus-namnområdet

Öppna Azure Portal och gå till resursgruppen az204-svcbus-rg.
Välj den az204svcbus-resurs som du skapade.
Välj Principer för delad åtkomst i avsnittet Inställningar och välj sedan principen RootManageSharedAccessKey .
Kopiera den primära anslutningssträngen från dialogrutan som öppnas och spara den i en fil, eller lämna portalen öppen och kopiera nyckeln vid behov.

Skapa konsolapp för att skicka meddelanden till kön

Öppna en lokal terminal och skapa och ändra till en katalog med namnet az204svcbus och kör sedan kommandot för att starta Visual Studio Code.
```
code .
```
Öppna terminalen i Visual Studio Code genom att välja Terminal > Ny terminal i menyraden och kör följande kommandon för att skapa konsolappen och lägga till paketet Azure.Messaging.ServiceBus .
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
Lägg till följande using instruktioner överst i filen efter den aktuella using instruktionen i Program.cs.
```
using Azure.Messaging.ServiceBus;
```

Lägg till följande variabler i koden och ange variabeln connectionString till den anslutningssträng som du fick tidigare.

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

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

Lägg till följande kod under de variabler som du nyss lade till. Mer information finns i kodkommentar.

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

Spara filen och kör dotnet build kommandot för att säkerställa att det inte finns några fel.
Kör programmet med kommandot dotnet run och vänta på följande bekräftelsemeddelande. Tryck sedan på valfri tangent för att avsluta programmet.
```
A batch of three messages has been published to the queue.
```

Granska resultat

Logga in på Azure Portal och navigera till Service Bus-namnområdet.
Välj Köer i avsnittet Entiteter i navigeringsfönstret och välj sedan az204-queue i listan.
Välj Service Bus Explorer i navigeringsfönstret Service Bus Queue.
Välj Granska från början och de tre meddelanden som skickades visas.

Uppdatera projektet för att ta emot meddelanden till kön

I det här avsnittet uppdaterar du programmet för att ta emot meddelanden från kön.

Lägg till följande kod i slutet av den befintliga koden. Mer information finns i kodkommentar.

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

dotnet build Använd kommandot för att säkerställa att det inte finns några fel.
dotnet run Använd kommandot för att köra programmet. Den skickar ytterligare tre meddelanden till kön och hämtar sedan alla sex meddelanden. Tryck på valfri tangent för att stoppa mottagaren och programmet.
```
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
```
Kommentar

Eftersom programmet skickade två batchar med meddelanden innan de hämtades bör du se två batchar med tre meddelanden som representeras i utdata.
Gå tillbaka till portalen och välj Granska från början igen. Observera att inga meddelanden visas i kön eftersom vi har hämtat alla.

Rensa resurser

När resurserna inte längre behövs kan du använda az group delete kommandot i Azure Cloud Shell för att ta bort resursgruppen.

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