Ćwiczenie: wysyłanie i odbieranie komunikatów z kolejki usługi Service Bus przy użyciu platformy .NET.

30 min

W tym ćwiczeniu dowiesz się, jak wykonywać następujące czynności:

Utwórz przestrzeń nazw i kolejkę usługi Service Bus przy użyciu interfejsu wiersza polecenia platformy Azure.
Utwórz aplikację konsolową platformy .NET do wysyłania i odbierania komunikatów z kolejki.

Wymagania wstępne

Konto platformy Azure z aktywną subskrypcją. Jeśli jej jeszcze nie masz, możesz zarejestrować się w celu uzyskania bezpłatnej wersji próbnej na stronie https://azure.com/free.
Program Visual Studio Code na jednej z obsługiwanych platform.
Rozszerzenie obsługujące język C# dla programu Visual Studio Code.
Platforma .NET 8 jest platformą docelową ćwiczenia.

W tej sekcji otworzysz terminal i utworzysz kilka zmiennych używanych w pozostałej części ćwiczenia, aby utworzyć wpis polecenia i nieco łatwiej utworzyć unikatową nazwę zasobu.

Uruchom usługę Azure Cloud Shell i wybierz pozycję Bash i środowisko.
Utwórz zmienne używane w poleceniach interfejsu wiersza polecenia platformy Azure. Zastąp <myLocation> element regionem blisko Ciebie.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Tworzenie zasobów platformy Azure

Utwórz grupę zasobów do przechowywania tworzonych zasobów platformy Azure.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Utwórz przestrzeń nazw komunikatów usługi Service Bus. Następujące polecenie tworzy przestrzeń nazw przy użyciu utworzonej wcześniej zmiennej. Ukończenie operacji trwa kilka minut.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Tworzenie kolejki usługi Service Bus

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

Pobieranie parametry połączenia dla przestrzeni nazw usługi Service Bus

Otwórz witrynę Azure Portal i przejdź do grupy zasobów az204-svcbus-rg .
Wybierz utworzony zasób az204svcbus.
Wybierz pozycję Zasady dostępu współdzielonego w sekcji Ustawienia , a następnie wybierz zasady RootManageSharedAccessKey .
Skopiuj podstawowe parametry połączenia z okna dialogowego, które zostanie otwarte i zapisane w pliku, lub pozostaw portal otwarty i skopiuj klucz w razie potrzeby.

Tworzenie aplikacji konsolowej do wysyłania komunikatów do kolejki

Otwórz lokalny terminal i utwórz i przejdź do katalogu o nazwie az204svcbus , a następnie uruchom polecenie , aby uruchomić program Visual Studio Code.
```
code .
```
Otwórz terminal w programie Visual Studio Code, wybierając pozycję Terminal > Nowy terminal na pasku menu i uruchom następujące polecenia, aby utworzyć aplikację konsolową i dodać pakiet Azure.Messaging.ServiceBus .
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
W Program.cs dodaj następujące using instrukcje w górnej części pliku po bieżącej using instrukcji.
```
using Azure.Messaging.ServiceBus;
```

Dodaj następujące zmienne do kodu i ustaw zmienną connectionString na parametry połączenia uzyskaną wcześniej.

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

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

Dodaj następujący kod poniżej właśnie dodanych zmiennych. Aby uzyskać szczegółowe informacje, zobacz komentarze kodu.

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

Zapisz plik i uruchom polecenie , dotnet build aby upewnić się, że nie ma żadnych błędów.
Uruchom program przy użyciu dotnet run polecenia i zaczekaj na następujący komunikat potwierdzający. Następnie naciśnij dowolny, aby zamknąć program.
```
A batch of three messages has been published to the queue.
```

Przegląd wyników

Zaloguj się do witryny Azure Portal i przejdź do przestrzeni nazw usługi Service Bus.
Wybierz pozycję Kolejki w sekcji Jednostki okienka nawigacji, a następnie wybierz z listy pozycję az204-queue .
Wybierz Eksploratora usługi Service Bus w okienku nawigacji kolejki usługi Service Bus.
Wybierz pozycję Zobacz od początku i zostaną wyświetlone trzy wysłane komunikaty.

Aktualizowanie projektu w celu odbierania komunikatów do kolejki

W tej sekcji zaktualizujesz program w celu odbierania komunikatów z kolejki.

Dodaj następujący kod na końcu istniejącego kodu. Aby uzyskać szczegółowe informacje, zobacz komentarze kodu.

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 Użyj polecenia , aby upewnić się, że nie ma żadnych błędów.
Użyj polecenia , dotnet run aby uruchomić aplikację. Wysyła trzy kolejne komunikaty do kolejki, a następnie pobiera wszystkie sześć komunikatów. Naciśnij dowolny, aby zatrzymać odbiornik i aplikację.
```
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
```
Uwaga

Ponieważ aplikacja wysłała dwie partie komunikatów przed ich pobraniem, powinny zostać wyświetlone dwie partie trzech komunikatów reprezentowanych w danych wyjściowych.
Wróć do portalu i wybierz pozycję Zobacz ponownie. Zwróć uwagę, że w kolejce nie są wyświetlane żadne komunikaty, ponieważ pobraliśmy je wszystkie.

Czyszczenie zasobów

Gdy zasoby nie są już potrzebne, możesz użyć az group delete polecenia w usłudze Azure Cloud Shell, aby usunąć grupę zasobów.

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