Självstudie: Arbeta med Azure Queue Storage-köer i .NET

Artikel
04/28/2023

Azure Queue Storage implementerar molnbaserade köer för att möjliggöra kommunikation mellan komponenter i ett distribuerat program. Varje kö har en lista över meddelanden som kan läggas till av en avsändarkomponent och bearbetas av en mottagarkomponent. Med en kö kan ditt program skalas omedelbart för att möta efterfrågan. Den här artikeln visar de grundläggande stegen för att arbeta med en Azure Queue Storage-kö.

I den här guiden får du lära dig att:

Skapa ett Azure Storage-konto
Skapa appen
Lägga till Azure-klientbiblioteken
Lägg till stöd för asynkron kod
Skapa en kö
Infoga meddelanden i en kö
Ta bort meddelanden från kö
Ta bort en tom kö
Sök efter kommandoradsargument
Kompilera och köra appen

Förutsättningar

Hämta din kostnadsfria kopia av Visual Studio Code-redigeraren för flera plattformar.
Ladda ned och installera .NET Core SDK version 3.1 eller senare.
Om du inte har någon aktuell Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

Skapa ett Azure Storage-konto

Skapa först ett Azure Storage-konto. En stegvis guide för att skapa ett lagringskonto finns i Skapa ett lagringskonto. Det här är ett separat steg som du utför när du har skapat ett kostnadsfritt Azure-konto i förutsättningarna.

Skapa appen

Skapa ett .NET Core-program med namnet QueueApp. För enkelhetens skull skickar och tar den här appen emot meddelanden via kön.

I ett konsolfönster (till exempel cmd, PowerShell eller Azure CLI) använder du dotnet new kommandot för att skapa en ny konsolapp med namnet QueueApp. Det här kommandot skapar ett enkelt "hello world" C#-projekt med en enda källfil med namnet Program.cs.
```
dotnet new console -n QueueApp
```

Växla till den nya mappen QueueApp och kompilera appen så att du ser att allting fungerar.

cd QueueApp

dotnet build

Du bör se resultat som liknar följande utdata:

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

Lägga till Azure-klientbiblioteken

Lägg till Azure Storage-klientbiblioteken i projektet med hjälp dotnet add package av kommandot .

Kör följande kommando från projektmappen i konsolfönstret.
```
dotnet add package Azure.Storage.Queues
```

Lägga till using-instruktioner

Från kommandoraden i projektkatalogen skriver du code . för att öppna Visual Studio Code i den aktuella katalogen. Låt kommandoradsfönstret vara öppet. Det kommer att finnas fler kommandon att köra senare. Om du uppmanas att lägga till C#-tillgångar som krävs för att skapa och felsöka klickar du på knappen Ja .
Program.cs Öppna källfilen och lägg till följande namnområden direkt efter -instruktionenusing System;. Den här appen använder typer från dessa namnområden för att ansluta till Azure Storage och arbeta med köer.
```
using System.Threading.Tasks;
using Azure.Storage.Queues;
using Azure.Storage.Queues.Models;
```
Spara filen Program.cs.

Lägg till stöd för asynkron kod

Eftersom appen använder molnresurser körs koden asynkront.

Uppdatera metoden så att den Main körs asynkront. Ersätt void med ett async Task returvärde.
```
static async Task Main(string[] args)
```
Spara filen Program.cs.

Skapa en kö

Innan du gör några anrop till Azure-API:er måste du hämta dina autentiseringsuppgifter från Azure Portal.

Kopiera dina autentiseringsuppgifter från Azure-portalen

När exempelprogrammet skickar en begäran till Azure Storage måste det auktoriseras. Om du vill auktorisera en begäran lägger du till dina autentiseringsuppgifter för lagringskontot i programmet som en anslutningssträng. Följ dessa steg om du vill visa dina autentiseringsuppgifter för lagringskontot:

Logga in på Azure-portalen.
Leta rätt på ditt lagringskonto.
I menyfönstret för lagringskontot går du till Säkerhet + nätverk och väljer Åtkomstnycklar. Här kan du visa kontoåtkomstnycklarna och den fullständiga anslutningssträngen för varje nyckel.
I fönstret Åtkomstnycklar väljer du Visa nycklar.
Leta upp värdet för Anslutningssträng i avsnittet key1. Välj ikonen Kopiera till Urklipp för att kopiera anslutningssträngen. Du lägger till värdet för anslutningssträngen i en miljövariabel i nästa avsnitt.

Konfigurera anslutningssträngen för lagring

När du har kopierat anslutningssträngen skriver du den till en ny miljövariabel på den lokala datorn som kör programmet. Konfigurera miljövariabeln genom att öppna ett konsolfönster och följa anvisningarna för ditt operativsystem. Ersätt <yourconnectionstring> med den faktiska anslutningssträngen.

Windows
Linux och macOS

setx AZURE_STORAGE_CONNECTION_STRING "<yourconnectionstring>"

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

När du har lagt till miljövariabeln i Windows måste du starta en ny instans av kommandofönstret.

Starta om program

När du har lagt till miljövariabeln startar du om alla program som körs och som behöver läsa miljövariabeln. Starta till exempel om utvecklingsmiljön eller redigeringsprogrammet innan du fortsätter.

Lägga till anslutningssträngen i appen

Lägg till anslutningssträngen i appen så att den kan komma åt lagringskontot.

Växla tillbaka till Visual Studio Code.
Main I metoden ersätter du Console.WriteLine("Hello, World"); koden med följande rad som hämtar anslutningssträngen från miljövariabeln.
```
string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING");
```
Lägg till följande kod för Main att skapa ett köobjekt, som senare skickas till metoderna för att skicka och ta emot.
```
QueueClient queue = new QueueClient(connectionString, "mystoragequeue");
```
Spara filen.

Infoga meddelanden i kön

Skapa en ny metod för att skicka ett meddelande till kön.

Lägg till följande InsertMessageAsync metod i klassen Program .

Den här metoden skickas en köreferens. En ny kö skapas, om den inte redan finns, genom att anropa CreateIfNotExistsAsync. Sedan lägger newMessage den till i kön genom att anropa SendMessageAsync.
```
static async Task InsertMessageAsync(QueueClient theQueue, string newMessage)
{
    if (null != await theQueue.CreateIfNotExistsAsync())
    {
        Console.WriteLine("The queue was created.");
    }

    await theQueue.SendMessageAsync(newMessage);
}
```
Valfri: Som standard är den maximala tidsgränsen för ett meddelande inställd på sju dagar. Du kan ange ett positivt tal för meddelandet time-to-live. Följande kodfragment lägger till ett meddelande som aldrig upphör att gälla.

Om du vill lägga till ett meddelande som inte upphör att gälla använder Timespan.FromSeconds(-1) du i anropet till SendMessageAsync.
```
await theQueue.SendMessageAsync(newMessage, default, TimeSpan.FromSeconds(-1), default);
```
Spara filen.

Ett kömeddelande måste vara i ett format som är kompatibelt med en XML-begäran med UTF-8-kodning. Ett meddelande kan vara upp till 64 kB stort. Om ett meddelande innehåller binära data, base64-koda meddelandet.

Ta bort meddelanden från kö

Skapa en ny metod för att hämta ett meddelande från kön. När meddelandet har tagits emot är det viktigt att ta bort det från kön så att det inte bearbetas mer än en gång.

Lägg till en ny metod med namnet RetrieveNextMessageAsync i klassen Program .

Den här metoden tar emot ett meddelande från kön genom att anropa ReceiveMessagesAsyncoch skickar 1 in den första parametern för att endast hämta nästa meddelande i kön. När meddelandet har tagits emot tar du bort det från kön genom att anropa DeleteMessageAsync.

När ett meddelande skickas till kön med en version av SDK före v12, är det automatiskt Base64-kodat. Från och med v12 togs den funktionen bort. När du hämtar ett meddelande med v12 SDK avkodas det inte automatiskt. Du måste uttryckligen Base64-avkoda innehållet själv.
```
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;
}
```
Spara filen.

Ta bort en tom kö

Det är bästa praxis i slutet av ett projekt att identifiera om du fortfarande behöver de resurser som du har skapat. Resurser som fortsätter att köras kostar pengar. Om kön finns men är tom frågar du användaren om de vill ta bort den.

RetrieveNextMessageAsync Expandera metoden för att inkludera en uppmaning om att ta bort den tomma kön.

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

Spara filen.

Sök efter kommandoradsargument

Om det finns några kommandoradsargument som skickas till appen antar du att de är ett meddelande som ska läggas till i kön. Koppla ihop argumenten för att skapa en sträng. Lägg till den här strängen i meddelandekön genom att anropa den InsertMessageAsync metod som vi lade till tidigare.

Om det inte finns några kommandoradsargument kan du försöka med en hämtningsåtgärd. RetrieveNextMessageAsync Anropa metoden för att hämta nästa meddelande i kön.

Vänta slutligen på användarindata innan du avslutar genom att anropa Console.ReadLine.

Main Expandera metoden för att söka efter kommandoradsargument och vänta på användarindata.

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

Spara filen.

Fullständig kod

Här är den fullständiga kodlistan för det här projektet.

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

Kompilera och köra appen

Från kommandoraden i projektkatalogen kör du följande dotnet-kommando för att skapa projektet.
```
dotnet build
```

När projektet har skapats kör du följande kommando för att lägga till det första meddelandet i kön.

dotnet run First queue message

Du bör se dessa utdata:

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

Kör appen utan kommandoradsargument för att ta emot och ta bort det första meddelandet i kön.
```
dotnet run
```

Fortsätt att köra appen tills alla meddelanden tas bort. Om du kör den en gång till får du ett meddelande om att kön är tom och en uppmaning om att ta bort kön.

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

Nästa steg

I den här självstudiekursen lärde du dig att:

Skapa en kö
Lägga till och ta bort meddelanden från en kö
Ta bort en Azure Queue Storage-kö

Mer information finns i snabbstarterna för Azure Queue Storage.

Snabbstart för köer för portalen

Relaterade kodexempel med inaktuella .NET version 11.x SDK:er finns i Kodexempel med .NET version 11.x.

Dela via