Esercitazione: Usare le code di Archiviazione code di Azure in .NET

Articolo
08/08/2024

Archiviazione code di Azure implementa code basate sul cloud per consentire la comunicazione tra i componenti di un'applicazione distribuita. Ogni coda gestisce un elenco di messaggi che possono essere aggiunti da un componente mittente ed elaborati da un componente destinatario. Con una coda, l'applicazione può essere ridimensionata immediatamente per soddisfare la richiesta. Questo articolo illustra i passaggi di base per usare una coda di Archiviazione code di Azure.

In questa esercitazione apprenderai a:

Creare un account di Archiviazione di Azure
Creare l'app
Aggiungere le librerie client di Azure
Aggiungere il supporto per il codice asincrono
Crea una coda
Inserire i messaggi in una coda
Rimuovere dalla coda i messaggi
Eliminare una coda vuota
Cercare gli argomenti della riga di comando
Compilare ed eseguire l'app

Prerequisiti

Ottenere la copia gratuita dell'editor Visual Studio Code multipiattaforma.
Scaricare e installare .NET Core SDK versione 3.1 o successiva.
Se non si ha una sottoscrizione di Azure corrente, creare un account gratuito prima di iniziare.

Creare un account di Archiviazione di Azure

Creare prima di tutto un account di archiviazione di Azure.

Per una guida dettagliata sulla creazione di un account di archiviazione, vedere Creare un account di archiviazione. Si tratta di un passaggio che viene eseguito separatamente dopo la creazione di un account Azure gratuito nei prerequisiti.
Assicurarsi che all'account utente sia stato assegnato il ruolo Collaboratore dati coda archiviazione, con ambito all'account di archiviazione, al gruppo di risorse padre o alla sottoscrizione. Vedere Eseguire l'autenticazione in Azure.

Creare l'app

Creare un'applicazione .NET Core denominata QueueApp. Per semplicità, questa app invierà e riceverà messaggi tramite la coda.

In una finestra della console, come cmd, PowerShell o l'interfaccia della riga di comando di Azure, usare il comando dotnet new per creare una nuova app console denominata QueueApp. Questo comando crea un semplice progetto C# "hello world" con un singolo file di origine denominato Program.cs.
```
dotnet new console -n QueueApp
```

Passare alla cartella QueueApp appena creata e compilare l'app per verificare che tutto funzioni correttamente.

cd QueueApp

dotnet build

Verrà visualizzata un output simile al seguente:

C:\Tutorials>dotnet new console -n QueueApp
The template "Console Application" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on QueueApp\QueueApp.csproj...
  Restore completed in 155.63 ms for C:\Tutorials\QueueApp\QueueApp.csproj.

Restore succeeded.

C:\Tutorials>cd QueueApp

C:\Tutorials\QueueApp>dotnet build
Microsoft (R) Build Engine version 16.0.450+ga8dc7f1d34 for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

  Restore completed in 40.87 ms for C:\Tutorials\QueueApp\QueueApp.csproj.
  QueueApp -> C:\Tutorials\QueueApp\bin\Debug\netcoreapp3.1\QueueApp.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)

Time Elapsed 00:00:02.40

C:\Tutorials\QueueApp>_

Aggiungere le librerie client di Azure

Aggiungere le librerie client di Archiviazione di Azure al progetto usando il comando dotnet add package.

Eseguire il comando seguente dalla cartella del progetto nella finestra della console.
```
dotnet add package Azure.Storage.Queues
```

Aggiungere istruzioni using

Nella riga di comando nella directory del progetto digitare code . per aprire Visual Studio Code nella directory corrente. Tenere aperta la finestra della riga di comando. Più avanti sarà necessario eseguire altri comandi. Se viene chiesto di aggiungere asset C# necessari per la compilazione e il debug, fare clic sul pulsante Sì.
Aprire il Program.cs file di origine e aggiungere gli spazi dei nomi seguenti subito dopo l'istruzione using System; . Questa app usa i tipi di questi spazi dei nomi per connettersi ad Archiviazione di Azure e servirsi delle code.
```
using System.Threading.Tasks;
using Azure.Storage.Queues;
using Azure.Storage.Queues.Models;
```
Salvare il file Program.cs.

Aggiungere il supporto per il codice asincrono

Poiché l'app usa le risorse cloud, il codice viene eseguito in modo asincrono.

Aggiornare il metodo per l'esecuzione Main asincrona. Sostituire void con un valore restituito async Task .
```
static async Task Main(string[] args)
```
Salvare il file Program.cs.

Crea una coda

Prima di effettuare chiamate alle API di Azure, è necessario assicurarsi di essere autenticati con lo stesso account Microsoft Entra a cui è stato assegnato il ruolo. Dopo l'autenticazione, è possibile creare e autorizzare un QueueClient oggetto usando DefaultAzureCredential per accedere ai dati della coda nell'account di archiviazione. DefaultAzureCredential individua e usa automaticamente l'account a cui hai eseguito l'accesso. Per informazioni su come accedere e quindi creare un QueueClient oggetto, vedere Autorizzare l'accesso e creare un oggetto client.

Inserire i messaggi nella coda

Creare un nuovo metodo per inviare un messaggio nella coda.

Aggiungere il metodo InsertMessageAsync alla classe Program.

A questo metodo viene passato un riferimento alla coda. Se non esiste già, viene creata una nuova coda chiamando CreateIfNotExistsAsync. Viene quindi aggiunto newMessage alla coda chiamando SendMessageAsync.
```
static async Task InsertMessageAsync(QueueClient theQueue, string newMessage)
{
    if (null != await theQueue.CreateIfNotExistsAsync())
    {
        Console.WriteLine("The queue was created.");
    }

    await theQueue.SendMessageAsync(newMessage);
}
```
Facoltativo: per impostazione predefinita, il tempo massimo per un messaggio è impostato su sette giorni. È possibile specificare qualsiasi numero positivo per la durata massima del messaggio. Il frammento di codice seguente aggiunge un messaggio che non scade mai.

Per aggiungere un messaggio che non scade, usare Timespan.FromSeconds(-1) nella chiamata a SendMessageAsync.
```
await theQueue.SendMessageAsync(newMessage, default, TimeSpan.FromSeconds(-1), default);
```
Salvare il file.

Un messaggio della coda deve essere in un formato compatibile con una richiesta XML con codifica UTF-8. Un messaggio può avere una dimensione massima di 64 kB. Se un messaggio contiene dati binari, usare la codifica Base64.

Rimuovere dalla coda i messaggi

Creare un nuovo metodo per recuperare un messaggio dalla coda. Dopo che il messaggio è stato ricevuto correttamente, è importante eliminarlo dalla coda in modo che non venga elaborato più volte.

Aggiungere un nuovo metodo chiamato RetrieveNextMessageAsync alla Program classe.

Questo metodo riceve un messaggio dalla coda chiamando ReceiveMessagesAsync, passando 1 nel primo parametro per recuperare solo il messaggio successivo nella coda. Dopo la ricezione del messaggio, eliminarlo dalla coda chiamando DeleteMessageAsync.

I messaggi inviati alla coda con una versione dell'SDK precedente a v12 vengono automaticamente codificati in Base64. A partire dalla versione 12 la funzionalità è stata rimossa. I messaggi recuperati con l'SDK v12 non vengono automaticamente decodificati in Base64. È necessario decodificare esplicitamente in Base64 il contenuto.
```
static async Task<string> RetrieveNextMessageAsync(QueueClient theQueue)
{
    if (await theQueue.ExistsAsync())
    {
        QueueProperties properties = await theQueue.GetPropertiesAsync();

        if (properties.ApproximateMessagesCount > 0)
        {
            QueueMessage[] retrievedMessage = await theQueue.ReceiveMessagesAsync(1);
            string theMessage = retrievedMessage[0].Body.ToString();
            await theQueue.DeleteMessageAsync(retrievedMessage[0].MessageId, retrievedMessage[0].PopReceipt);
            return theMessage;
        }

        return null;
    }

    return null;
}
```
Salvare il file.

Eliminare una coda vuota

È buona norma, alla fine di un progetto, verificare se le risorse create sono ancora necessarie. Le risorse che rimangono in esecuzione hanno un costo. Se la coda esiste, ma è vuota, chiedere all'utente se vuole eliminarla.

Espandere il RetrieveNextMessageAsync metodo per includere un prompt per eliminare la coda vuota.

static async Task<string> RetrieveNextMessageAsync(QueueClient theQueue)
{
    if (await theQueue.ExistsAsync())
    {
        QueueProperties properties = await theQueue.GetPropertiesAsync();

        if (properties.ApproximateMessagesCount > 0)
        {
            QueueMessage[] retrievedMessage = await theQueue.ReceiveMessagesAsync(1);
            string theMessage = retrievedMessage[0].Body.ToString();
            await theQueue.DeleteMessageAsync(retrievedMessage[0].MessageId, retrievedMessage[0].PopReceipt);
            return theMessage;
        }
        else
        {
            Console.Write("The queue is empty. Attempt to delete it? (Y/N) ");
            string response = Console.ReadLine();

            if (response.ToUpper() == "Y")
            {
                await theQueue.DeleteIfExistsAsync();
                return "The queue was deleted.";
            }
            else
            {
                return "The queue was not deleted.";
            }
        }
    }
    else
    {
        return "The queue does not exist. Add a message to the command line to create the queue and store the message.";
    }
}

Salvare il file.

Cercare gli argomenti della riga di comando

Se sono presenti argomenti della riga di comando passati all'app, presupporre che si tratti di un messaggio da aggiungere alla coda. Unire gli argomenti per creare una stringa. Aggiungere questa stringa alla coda di messaggi chiamando il InsertMessageAsync metodo aggiunto in precedenza.

Se non sono presenti argomenti della riga di comando, provare a eseguire un'operazione di recupero. Chiamare il RetrieveNextMessageAsync metodo per recuperare il messaggio successivo nella coda.

Attendere infine l'input dell'utente prima di uscire chiamando Console.ReadLine.

Espandere il Main metodo per verificare la presenza di argomenti della riga di comando e attendere l'input dell'utente. Nel frammento di codice seguente assicurarsi di sostituire il {storageAccountName} segnaposto con il nome dell'account di archiviazione.

static async Task Main(string[] args)
{
   QueueClient queue = new QueueClient(
      new Uri($"https://{storageAccountName}.queue.core.windows.net/mystoragequeue"),
      new DefaultAzureCredential());

   if (args.Length > 0)
   {
      string value = String.Join(" ", args);
      await InsertMessageAsync(queue, value);
      Console.WriteLine($"Sent: {value}");
   }
   else
   {
      string value = await RetrieveNextMessageAsync(queue);
      Console.WriteLine($"Received: {value}");
   }

   Console.Write("Press Enter...");
   Console.ReadLine();
}

Salvare il file.

Codice completo

Ecco il listato di codice completo per questo progetto.

using System;
using System.Threading.Tasks;
using Azure.Storage.Queues;
using Azure.Storage.Queues.Models;
using Azure.Identity;

namespace QueueApp
{
    class Program
    {
        static async Task Main(string[] args)
        {
            QueueClient queue = new QueueClient(
               new Uri($"https://{storageAccountName}.queue.core.windows.net/mystoragequeue"),
               new DefaultAzureCredential());

            if (args.Length > 0)
            {
                string value = String.Join(" ", args);
                await InsertMessageAsync(queue, value);
                Console.WriteLine($"Sent: {value}");
            }
            else
            {
                string value = await RetrieveNextMessageAsync(queue);
                Console.WriteLine($"Received: {value}");
            }

            Console.Write("Press Enter...");
            Console.ReadLine();
        }

        static async Task InsertMessageAsync(QueueClient theQueue, string newMessage)
        {
            if (null != await theQueue.CreateIfNotExistsAsync())
            {
                Console.WriteLine("The queue was created.");
            }

            await theQueue.SendMessageAsync(newMessage);
        }

        static async Task<string> RetrieveNextMessageAsync(QueueClient theQueue)
        {
            if (await theQueue.ExistsAsync())
            {
                QueueProperties properties = await theQueue.GetPropertiesAsync();

                if (properties.ApproximateMessagesCount > 0)
                {
                    QueueMessage[] retrievedMessage = await theQueue.ReceiveMessagesAsync(1);
                    string theMessage = retrievedMessage[0].Body.ToString();
                    await theQueue.DeleteMessageAsync(retrievedMessage[0].MessageId, retrievedMessage[0].PopReceipt);
                    return theMessage;
                }
                else
                {
                    Console.Write("The queue is empty. Attempt to delete it? (Y/N) ");
                    string response = Console.ReadLine();

                    if (response.ToUpper() == "Y")
                    {
                        await theQueue.DeleteIfExistsAsync();
                        return "The queue was deleted.";
                    }
                    else
                    {
                        return "The queue was not deleted.";
                    }
                }
            }
            else
            {
                return "The queue does not exist. Add a message to the command line to create the queue and store the message.";
            }
        }
    }
}

Compilare ed eseguire l'app

Dalla riga di comando nella directory del progetto eseguire il comando dotnet seguente per compilare il progetto.
```
dotnet build
```

Dopo aver compilato il progetto, eseguire il comando seguente per aggiungere il primo messaggio alla coda.

dotnet run First queue message

Dovrebbe essere visualizzato questo output:

C:\Tutorials\QueueApp>dotnet run First queue message
The queue was created.
Sent: First queue message
Press Enter..._

Eseguire l'app senza argomenti della riga di comando per ricevere e rimuovere il primo messaggio nella coda.
```
dotnet run
```

Continuare a eseguire l'app fino alla rimozione di tutti i messaggi. Se la si esegue ancora una volta, verranno visualizzati un messaggio che informa che la coda è vuota e un prompt per eliminare la coda.

C:\Tutorials\QueueApp>dotnet run First queue message
The queue was created.
Sent: First queue message
Press Enter...

C:\Tutorials\QueueApp>dotnet run Second queue message
Sent: Second queue message
Press Enter...

C:\Tutorials\QueueApp>dotnet run Third queue message
Sent: Third queue message
Press Enter...

C:\Tutorials\QueueApp>dotnet run
Received: First queue message
Press Enter...

C:\Tutorials\QueueApp>dotnet run
Received: Second queue message
Press Enter...

C:\Tutorials\QueueApp>dotnet run
Received: Third queue message
Press Enter...

C:\Tutorials\QueueApp>dotnet run
The queue is empty. Attempt to delete it? (Y/N) Y
Received: The queue was deleted.
Press Enter...

C:\Tutorials\QueueApp>_

Passaggi successivi

Questa esercitazione ha descritto come:

Crea una coda
Aggiungere e rimuovere messaggi da una coda
Eliminare una coda di Archiviazione code di Azure

Per altre informazioni, vedere gli argomenti di avvio rapido su Archiviazione code di Azure.

Guida di avvio rapido sulle code per il portale

Per esempi di codice correlati che usano SDK .NET versione 11.x deprecata, vedere Esempi di codice con .NET versione 11.x.

Condividi tramite