Cvičení: Odesílání a příjem zpráv z fronty služby Service Bus pomocí .NET

30 min

V tomto cvičení se naučíte:

Vytvořte obor názvů služby Service Bus a frontu pomocí Azure CLI.
Vytvořte konzolovou aplikaci .NET pro odesílání a příjem zpráv z fronty.

Požadavky

Účet Azure s aktivním předplatným. Pokud ho ještě nemáte, můžete si zaregistrovat bezplatnou zkušební verzi na webu https://azure.com/free.
Visual Studio Code na jedné z podporovaných platforem
Rozšíření pro jazyk C# pro Visual Studio Code
.NET 8 je cílová architektura pro cvičení.

V této části otevřete terminál a vytvoříte několik proměnných použitých ve zbytku cvičení, abyste usnadnili zadávání příkazů a vytvoření jedinečného názvu prostředku.

Spusťte Azure Cloud Shell a vyberte Bash a prostředí.
Vytvořte proměnné použité v příkazech Azure CLI. Nahraďte <myLocation> oblastí blízko vás.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Vytvoření zdrojů Azure

Vytvořte skupinu prostředků pro uchovávání prostředků Azure, které vytváříte.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Vytvořte obor názvů zasílání zpráv služby Service Bus. Následující příkaz vytvoří obor názvů pomocí proměnné, kterou jste vytvořili dříve. Dokončení operace trvá několik minut.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Vytvoření fronty Service Busu

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

Načtení připojovací řetězec pro obor názvů služby Service Bus

Otevřete Azure Portal a přejděte do skupiny prostředků az204-svcbus-rg .
Vyberte prostředek az204svcbus, který jste vytvořili.
V části Nastavení vyberte zásady sdíleného přístupu a pak vyberte zásadu RootManageSharedAccessKey.
Zkopírujte primární připojovací řetězec z dialogového okna, které se otevře a uloží do souboru, nebo ponechte portál otevřený a v případě potřeby klíč zkopírujte.

Vytvoření konzolové aplikace pro odesílání zpráv do fronty

Otevřete místní terminál a vytvořte a přejděte do adresáře az204svcbus a spusťte příkaz pro spuštění editoru Visual Studio Code.
```
code .
```
Otevřete terminál v editoru Visual Studio Code tak , že v řádku nabídek vyberete Terminál > nový terminál a spustíte následující příkazy, které vytvoří konzolovou aplikaci a přidá balíček Azure.Messaging.ServiceBus .
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
V Program.cs přidejte následující using příkazy do horní části souboru za aktuální using příkaz.
```
using Azure.Messaging.ServiceBus;
```

Do kódu přidejte následující proměnné a nastavte connectionString ji na připojovací řetězec, které jste získali dříve.

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

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

Pod právě přidané proměnné přidejte následující kód. Podrobnosti najdete v komentářích ke kódu.

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

Uložte soubor a spusťte dotnet build příkaz, aby nedošlo k žádným chybám.
Spusťte program pomocí dotnet run příkazu a počkejte na následující potvrzovací zprávu. Potom program ukončete stisknutím libovolné klávesy.
```
A batch of three messages has been published to the queue.
```

Kontrola výsledků

Přihlaste se k webu Azure Portal a přejděte do oboru názvů služby Service Bus.
V části Entity v navigačním podokně vyberte Fronty a pak ze seznamu vyberte az204-queue.
V navigačním podokně fronty služby Service Bus vyberte Service Bus Explorer .
Vyberte Náhled od začátku a zobrazí se tři odeslané zprávy.

Aktualizace projektu pro příjem zpráv do fronty

V této části aktualizujete program tak, aby přijímal zprávy z fronty.

Na konec existujícího kódu přidejte následující kód. Podrobnosti najdete v komentářích ke kódu.

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 Pomocí příkazu se ujistěte, že nedošlo k žádným chybám.
dotnet run Ke spuštění aplikace použijte příkaz. Odešle do fronty tři další zprávy a pak načte všechny šest zpráv. Stisknutím libovolné klávesy zastavte přijímač a aplikaci.
```
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
```
Poznámka:

Vzhledem k tomu, že aplikace před načtením odeslala dvě dávky zpráv, měly by se ve výstupu zobrazit dvě dávky tří zpráv.
Vraťte se na portál a znovu vyberte Náhled. Všimněte si, že se ve frontě nezobrazují žádné zprávy, protože jsme je všechny načetli.

Vyčištění prostředků

Pokud už prostředky nepotřebujete, můžete skupinu prostředků odebrat pomocí az group delete příkazu v Azure Cloud Shellu.

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