Esercizio: Inviare e ricevere messaggi da una coda del bus di servizio usando .NET.

30 minuti

In questo esercizio si apprenderà come:

Creare uno spazio dei nomi del bus di servizio e una coda usando l'interfaccia della riga di comando di Azure.
Creare un'applicazione console .NET per inviare e ricevere messaggi dalla coda.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Se non è ancora disponibile alcuna sottoscrizione, è possibile registrarsi per una valutazione gratuita all'indirizzo https://azure.com/free.
Visual Studio Code in una delle piattaforme supportate.
Estensione C# per Visual Studio Code.
.NET 8 è il framework di destinazione per i passaggi seguenti.

In questa sezione si aprirà il terminale e si creeranno alcune variabili che verranno usate nel resto dell'esercizio per semplificare l'immissione dei comandi e la creazione di nomi di risorse univoci.

Avviare Azure Cloud Shell, quindi selezionare Bash e l'ambiente.
Creare le variabili usate nei comandi dell'interfaccia della riga di comando di Azure. Sostituire <myLocation> con un'area vicina.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Creare risorse Azure

Creare un gruppo di risorse in cui contenere le risorse di Azure che verranno create.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Creare uno spazio dei nomi di messaggistica del bus di servizio. Il comando seguente creerà uno spazio dei nomi usando la variabile creata in precedenza. Il completamento dell'operazione richiede alcuni minuti.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Creare una coda del bus di servizio

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

Recuperare la stringa di connessione per lo spazio dei nomi del bus di servizio

Aprire il portale di Azure e passare al gruppo di risorse az204-svcbus-rg.
Selezionare la risorsa az204svcbus creata.
Nella sezione Impostazioni selezionare Criteri di accesso condivisi e quindi selezionare il criterio RootManageSharedAccessKey.
Copiare la stringa di connessione primaria dalla finestra di dialogo visualizzata e salvarla in un file oppure lasciare aperto il portale e copiare la chiave quando è necessario.

Creare un'app console per inviare messaggi alla coda

Aprire un terminale locale, quindi creare e passare a una directory denominata az204svcbus ed eseguire il comando per avviare Visual Studio Code.
```
code .
```
Aprire il terminale in Visual Studio Code selezionando Terminale > Nuovo terminale sulla barra dei menu ed eseguire i comandi seguenti per creare l'app console e aggiungere il pacchetto Azure.Messaging.ServiceBus.
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
In Program.cs aggiungere le istruzioni using seguenti all'inizio del file dopo l'istruzione using corrente.
```
using Azure.Messaging.ServiceBus;
```

Aggiungere le variabili seguenti al codice e impostare la connectionString variabile sulla stringa di connessione ottenuta in precedenza.

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

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

Aggiungere il codice seguente sotto le variabili appena aggiunte. Per i dettagli, vedere i commenti nel codice.

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

Salvare il file ed eseguire il comando dotnet build per assicurarsi che non siano presenti errori.
Esegui il programma usando il comando dotnet run e attendi il messaggio di conferma seguente. Quindi premi qualsiasi pulsante per uscire dal programma.
```
A batch of three messages has been published to the queue.
```

Verificare i risultati

Accedere al portale di Azure e passare allo spazio dei nomi del bus di servizio.
Selezionare Code dalla sezione Entità del pannello di navigazione, quindi selezionare az204-queue dall'elenco.
Selezionare Service Bus Explorer nel riquadro di spostamento della coda del bus di servizio.
Selezionare Visualizza in anteprima dall'inizio e i tre messaggi inviati vengono visualizzati.

Aggiornare il progetto per ricevere messaggi nella coda

In questa sezione si aggiorna il programma per ricevere messaggi dalla coda.

Aggiungere il codice riportato di seguito alla fine del codice esistente. Per i dettagli, vedere i commenti nel codice.

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

Usare il comando dotnet build per assicurarsi che non siano presenti errori.
Usare il comando dotnet run per eseguire l'applicazione. Invia tre messaggi alla coda e quindi recupera tutti e sei i messaggi. Premere un tasto qualsiasi per arrestare il destinatario e l'applicazione.
```
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
```
Nota

Poiché l'applicazione ha inviato due batch di messaggi prima di recuperarli, verranno visualizzati due batch di tre messaggi rappresentati nell'output.
Tornare al portale e selezionare Visualizza in anteprima dall'avvio di nuovo. Si noti che non vengono visualizzati messaggi nella coda perché sono stati recuperati tutti.

Pulire le risorse

Se le risorse non servono più, è possibile usare il comando az group delete in Azure Cloud Shell per rimuovere il gruppo di risorse.

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