Exercițiu: Trimiteți și primiți mesaje de la o coadă de magistrală de servicii utilizând .NET.

30 minute

În acest exercițiu înveți cum să:

Creați un spațiu de nume și o coadă pentru magistrala de servicii, utilizând CLI Azure.
Creați o aplicație consolă .NET pentru a trimite și primi mesaje din coadă.

Cerințe preliminare

Un cont Azure cu un abonament activ. Dacă nu aveți deja unul, vă puteți înscrie pentru o perioadă de încercare gratuită la https://azure.com/free.
Visual Studio Code pe una dintre platformele acceptate.
Extensia C# pentru Visual Studio Code.
.NET 8 este cadrul țintă pentru exercițiu.

În această secțiune, deschideți terminalul și creați câteva variabile utilizate pe tot parcursul exercițiului pentru a facilita introducerea comenzii și crearea unui nume unic de resurse.

Lansați Azure Cloud Shell și selectați Bash și mediul.
Creați variabile utilizate în comenzile CLI Azure. Înlocuiți-l <myLocation> cu o regiune din apropierea dvs.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Crearea resurselor Azure

Creați un grup de resurse pentru a stoca resursele Azure pe care le creați.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Creați un spațiu de nume pentru mesageria magistralei de servicii. Următoarea comandă creează un spațiu de nume utilizând variabila pe care ați creat-o anterior. Operațiunea durează câteva minute.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Crearea unei cozi de magistrală de servicii

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

Regăsiți șirul de conexiune pentru spațiul de nume Service Bus

Deschideți portalul Azure și navigați la grupul de resurse az204-svcbus-rg .
Selectați resursa az204svcbus pe care ați creat-o.
Selectați Politici de acces partajat în secțiunea Setări , apoi selectați politica RootManageSharedAccessKey .
Copiați șirul de conexiune principal din caseta de dialog care se deschide și salvați-l într-un fișier sau lăsați portalul deschis și copiați cheia atunci când este necesar.

Creați o aplicație consolă pentru a trimite mesaje către coadă

Deschideți un terminal local și creați și modificați într-un director numit az204svcbus și apoi executați comanda pentru a lansa Visual Studio Code.
```
code .
```
Deschideți terminalul în Visual Studio Code selectând Terminal New Terminal în bara de meniu și rulați următoarele comenzi pentru a crea aplicația consolă și a adăuga pachetul Azure.Messaging.ServiceBus>.
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
În Program.cs, adăugați următoarele using afirmații în partea de sus a fișierului după declarația curentă using .
```
using Azure.Messaging.ServiceBus;
```

Adăugați următoarele variabile la cod și setați variabila connectionString la șirul de conexiune pe care l-ați obținut anterior.

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

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

Adăugați următorul cod sub variabilele pe care tocmai le-ați adăugat. Consultați comentariile de cod pentru detalii.

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

Salvați fișierul și executați comanda pentru a dotnet build vă asigura că nu există erori.
Rulați programul utilizând dotnet run comanda și așteptați următorul mesaj de confirmare. Apoi apăsați orice tastă pentru a ieși din program.
```
A batch of three messages has been published to the queue.
```

Examinați rezultatele

Conectați-vă la portalul Azure și navigați la spațiul de nume al magistralei de servicii.
Selectați Cozi din secțiunea Entități a panoului de navigare, apoi selectați coada az204 din listă.
Selectați Explorator magistrală de servicii în panoul de navigare Coadă magistrală de servicii.
Selectați Peek din start și apar cele trei mesaje trimise.

Actualizați proiectul pentru a primi mesaje în coadă

În această secțiune, actualizați programul pentru a primi mesaje din coadă.

Adăugați următorul cod la sfârșitul codului existent. Consultați comentariile de cod pentru detalii.

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 Utilizați comanda pentru a vă asigura că nu există erori.
dotnet run Utilizați comanda pentru a rula aplicația. Trimite încă trei mesaje către coadă și apoi preia toate cele șase mesaje. Apăsați orice tastă pentru a opri receptorul și aplicația.
```
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
```
Notă

Deoarece aplicația a trimis două loturi de mesaje înainte de a le prelua, ar trebui să vedeți două loturi de trei mesaje reprezentate în ieșire.
Reveniți la portal și selectați Peek de la început din nou. Observați că nu apar mesaje în coadă, deoarece le-am recuperat pe toate.

Curățați resursele

Când resursele nu mai sunt necesare, puteți utiliza az group delete comanda din Componenta cloud Azure pentru a elimina grupul de resurse.

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

Continuare