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

Articolo
04/28/2023

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 verranno illustrate le procedure per:

Creare un account di Archiviazione di Azure
Creare l'app
Aggiungere le librerie client di Azure
Aggiungere il supporto per il codice asincrono
Creare 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.

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 file di origine Program.cs e aggiungere gli spazi dei nomi seguenti 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 Main per eseguire il codice in modo asincrono. Sostituire void con un valore restituito async Task.
```
static async Task Main(string[] args)
```
Salvare il file.Program.cs

Creare una coda

Prima di effettuare chiamate alle API di Azure, è necessario ottenere le credenziali dal portale di Azure.

Copiare le credenziali dal portale di Azure

Le richieste effettuate dall'applicazione di esempio ad Archiviazione di Azure devono essere autorizzate. Per autorizzare una richiesta, aggiungere all'applicazione le credenziali dell'account di archiviazione sotto forma di stringa di connessione. Per visualizzare le credenziali dell'account di archiviazione, seguire questa procedura:

Accedere al portale di Azure.
Individuare l'account di archiviazione.
Nel riquadro menu account di archiviazione, in Sicurezza e rete selezionare Chiavi di accesso. In questo caso è possibile visualizzare le chiavi di accesso dell'account e la stringa di connessione completa per ogni chiave.
Nel riquadro Chiavi di accesso selezionare Mostra chiavi.
Nella sezione key1 individuare il valore stringa di connessione . Selezionare l'icona Copia negli Appunti per copiare la stringa di connessione. Si aggiungerà il valore della stringa di connessione a una variabile di ambiente nella sezione successiva.

Configurare la stringa di connessione di archiviazione

Dopo aver copiato la stringa di connessione, scriverla in una nuova variabile di ambiente nel computer locale che esegue l'applicazione. Per impostare la variabile di ambiente, aprire una finestra della console e seguire le istruzioni per il sistema operativo specifico. Sostituire <yourconnectionstring> con la stringa di connessione effettiva.

Windows
Linux e macOS

setx AZURE_STORAGE_CONNECTION_STRING "<yourconnectionstring>"

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

Dopo aver aggiunto la variabile di ambiente in Windows, è necessario avviare una nuova istanza della finestra di comando.

Riavviare i programmi

Dopo aver aggiunto la variabile di ambiente, riavviare gli eventuali programmi in esecuzione che dovranno leggerla. Ad esempio, riavviare l'ambiente di sviluppo o l'editor prima di continuare.

Aggiungere la stringa di connessione all'app

Aggiungere la stringa di connessione nell'app in modo che possa accedere all'account di archiviazione.

Tornare a Visual Studio Code.
Nel metodo Main sostituire il codice Console.WriteLine("Hello, World"); con la riga seguente che ottiene la stringa di connessione dalla variabile di ambiente.
```
string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING");
```
Aggiungere il codice seguente a Main per creare un oggetto coda, che in seguito viene passato ai metodi send e receive.
```
QueueClient queue = new QueueClient(connectionString, "mystoragequeue");
```
Salvare il file.

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, la durata massima (TTL) di un messaggio è impostata 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 denominato RetrieveNextMessageAsync alla classe Program.

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. L'esecuzione continua delle risorse può avere un costo. Se la coda esiste, ma è vuota, chiedere all'utente se vuole eliminarla.

Espandere il metodo RetrieveNextMessageAsync 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 metodo InsertMessageAsync aggiunto prima.

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

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

Espandere il metodo Main per cercare gli argomenti della riga di comando e attendere l'input dell'utente.

static async Task Main(string[] args)
{
    string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING");

    QueueClient queue = new QueueClient(connectionString, "mystoragequeue");

    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;

namespace QueueApp
{
    class Program
    {
        static async Task Main(string[] args)
        {
            string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING");

            QueueClient queue = new QueueClient(connectionString, "mystoragequeue");

            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 venire 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

In questa esercitazione sono state illustrate le procedure per:

Creare 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 deprecati, vedere Esempi di codice con .NET versione 11.x.

Share via