Freigeben über

Erste Schritte mit Azure Queue Storage mit .NET

  • Artikel

Überblick

Azure Queue Storage bietet Cloud-Messaging zwischen Anwendungskomponenten. Beim Entwerfen von Anwendungen für die Skalierung werden Anwendungskomponenten häufig entkoppelt, sodass sie unabhängig voneinander skaliert werden können. Warteschlangenspeicher liefert asynchrones Messaging zwischen Anwendungskomponenten, unabhängig davon, ob sie in der Cloud, auf dem Desktop, auf einem lokalen Server oder auf einem mobilen Gerät ausgeführt werden. Der Warteschlangenspeicher unterstützt auch die Verwaltung asynchroner Aufgaben und das Erstellen von Prozessarbeitsflüssen.

Informationen zu diesem Tutorial

In diesem Lernprogramm wird gezeigt, wie .NET-Code für einige gängige Szenarien mit Azure Queue Storage geschrieben wird. Zu den behandelten Szenarien gehören das Erstellen und Löschen von Warteschlangen sowie das Hinzufügen, Lesen und Löschen von Warteschlangennachrichten.

Geschätzte Zeit bis zum Abschluss: 45 Minuten

Voraussetzungen

Was ist Queue-Speicher?

Azure Queue Storage ist ein Dienst zum Speichern großer Anzahl von Nachrichten, auf die von überall auf der Welt über authentifizierte Anrufe mit HTTP oder HTTPS zugegriffen werden kann. Eine einzelne Warteschlangennachricht kann bis zu 64 KB groß sein, und eine Warteschlange kann Millionen von Nachrichten bis zum Gesamtkapazitätslimit eines Speicherkontos enthalten. Der Warteschlangenspeicher wird häufig verwendet, um einen Arbeitsbestand zu erstellen, der asynchron verarbeitet werden kann.

Konzepte des Warteschlangendienstes

Der Azure-Warteschlangendienst enthält die folgenden Komponenten:

Azure Queue-Dienstkomponenten

  • Speicherkonto: Der gesamte Zugriff auf Azure Storage erfolgt über ein Speicherkonto. Weitere Informationen zu Speicherkonten finden Sie in der Speicherkontoübersicht.

  • Warteschlange: Eine Warteschlange enthält einen Satz von Nachrichten. Alle Nachrichten müssen sich in einer Warteschlange befinden. Beachten Sie, dass der Warteschlangenname nur aus Kleinbuchstaben bestehen darf. Informationen zum Benennen von Warteschlangen finden Sie unter Benennen von Warteschlangen und Metadaten.

  • Nachricht: Eine Nachricht in einem beliebigen Format und mit einer Größe von bis zu 64 KB. Die maximale Zeit, die eine Nachricht in der Warteschlange verbleiben kann, beträgt 7 Tage. Für Version 2017-07-29 oder höhere Versionen kann die maximale Gültigkeitsdauer eine beliebige positive Zahl sein. Mit -1 wird angegeben, dass die Nachricht nicht abläuft. Wird dieser Parameter ausgelassen, beträgt die Standardgültigkeitsdauer sieben Tage.

  • URL-Format: Warteschlangen können mithilfe des folgenden URL-Formats adressierbar sein: http://<storage account>.queue.core.windows.net/<queue>

    Die folgende URL behebt eine Warteschlange im Diagramm:

    http://myaccount.queue.core.windows.net/incoming-orders

Erstellen eines Azure-Speicherkontos

Die einfachste Möglichkeit zum Erstellen Ihres ersten Azure-Speicherkontos ist die Verwendung des Azure-Portals. Weitere Informationen finden Sie unter Erstellen von Speicherkonten.

Sie können auch ein Azure-Speicherkonto erstellen, indem Sie Azure PowerShell-, Azure CLI-oder den Azure Storage Resource Provider für .NET-verwenden.

Wenn Sie derzeit kein Speicherkonto in Azure erstellen möchten, können Sie auch den Azurite-Speicheremulator verwenden, um Ihren Code in einer lokalen Umgebung auszuführen und zu testen. Weitere Informationen finden Sie unter Verwenden des Azurite-Emulators für die lokale Azure Storage-Entwicklung.

Einrichten Ihrer Entwicklungsumgebung

Richten Sie als Nächstes Ihre Entwicklungsumgebung in Visual Studio ein, damit Sie die Codebeispiele in diesem Handbuch ausprobieren können.

Erstellen eines Windows-Konsolenanwendungsprojekts

Erstellen Sie in Visual Studio eine neue Windows-Konsolenanwendung. In den folgenden Schritten wird veranschaulicht, wie Sie eine Konsolenanwendung in Visual Studio 2019 erstellen. Die Schritte sind in anderen Versionen von Visual Studio ähnlich.

  1. Wählen Sie Datei>Neues>Projekt
  2. Wählen Sie Plattform>Windows
  3. Wählen Sie Konsolen-App (.NET Framework) aus.
  4. Wählen Sie Weiter aus.
  5. Geben Sie im Feld Projektname einen Namen für Ihre Anwendung ein.
  6. Wählen Sie Erstellen aus.

Alle Codebeispiele in diesem Lernprogramm können der Main() Methode der Program.cs Datei der Konsolenanwendung hinzugefügt werden.

Sie können die Azure Storage-Clientbibliotheken in jeder Art von .NET-Anwendung verwenden, einschließlich eines Azure-Clouddiensts oder einer Web-App sowie Desktop- und mobile Anwendungen. In diesem Handbuch verwenden wir eine Konsolenanwendung zur Einfachheit.

Verwenden von NuGet zum Installieren der erforderlichen Pakete

Sie müssen auf die folgenden vier Pakete in Ihrem Projekt verweisen, um dieses Lernprogramm abzuschließen:

Sie können NuGet verwenden, um diese Pakete abzurufen. Folgen Sie diesen Schritten:

  1. Klicken Sie mit der rechten Maustaste auf Ihr Projekt im Projektmappen-Explorer, und wählen Sie NuGet-Pakete verwaltenaus.
  2. Auswählen Durchsuchen
  3. Suchen Sie online nach Azure.Storage.Queues, und wählen Sie Installieren aus, um die Azure Storage-Clientbibliothek und deren Abhängigkeiten zu installieren. Dadurch werden auch die Bibliotheken "Azure.Storage.Common" und "Azure.Core" installiert, die für die Warteschlangenbibliothek benötigt werden.
  4. Suchen Sie online nach System.Configuration.ConfigurationManager, und wählen Sie Installieren aus, um den Configuration Manager zu installieren.

Ermitteln der Zielumgebung

Sie haben zwei Umgebungsoptionen zum Ausführen der Beispiele in diesem Handbuch:

  • Sie können Ihren Code für ein Azure Storage-Konto in der Cloud ausführen.
  • Sie können Ihren Code für den Azurite-Speicher-Emulator ausführen. Azurite ist eine lokale Umgebung, die ein Azure Storage-Konto in der Cloud emuliert. Azurite ist eine kostenlose Option zum Testen und Debuggen Ihres Codes, während Ihre Anwendung entwickelt wird. Der Emulator verwendet ein bekanntes Konto und einen bekannten Schlüssel. Weitere Informationen finden Sie unter Verwenden des Azurite-Emulators für lokale Azure Storage-Entwicklung und -Tests.

Hinweis

Sie können den Speicheremulator verwenden, um Kosten im Zusammenhang mit Azure Storage zu vermeiden. Wenn Sie sich jedoch für ein Azure Storage-Konto in der Cloud entscheiden, sind die Kosten für die Durchführung dieses Lernprogramms vernachlässigbar.

Rufen Sie Ihre Speicherverbindungszeichenfolge ab

Die Azure Storage-Clientbibliotheken für .NET unterstützen die Verwendung einer Verbindungszeichenfolge, um Endpunkte und Anmeldeinformationen für den Zugriff auf Speicherdienste zu konfigurieren. Weitere Informationen finden Sie unter Verwalten von Speicherkonto-Zugriffsschlüsseln.

Kopieren Ihrer Anmeldeinformationen aus dem Azure-Portal

Der Beispielcode muss den Zugriff auf Ihr Speicherkonto autorisieren. Um dies zu autorisieren, geben Sie der Anwendung Ihre Anmeldeinformationen für Ihr Speicherkonto in Form einer Verbindungszeichenfolge an. So können Sie die Anmeldedaten Ihres Speicherkontos ansehen:

  1. Navigieren Sie zum Azure-Portal.

  2. Suchen Sie nach Ihrem Speicherkonto.

  3. Wählen Sie im Abschnitt Einstellungen der Übersicht über das Speicherkonto, Zugriffsschlüsselaus. Ihre Kontozugriffsschlüssel sowie die vollständige Verbindungszeichenfolge für jeden Schlüssel werden angezeigt.

  4. Suchen Sie die Verbindungszeichenfolge Wert unter key1, und klicken Sie auf die Schaltfläche Kopieren, um die Verbindungszeichenfolge zu kopieren. Im nächsten Schritt fügen Sie einen Verbindungszeichenfolgenwert zu einer Umgebungsvariable hinzu.

    Screenshot: Kopieren einer Verbindungszeichenfolge aus dem Azure-Portal

Weitere Informationen zu Verbindungszeichenfolgen finden Sie unter Konfigurieren einer Verbindungszeichenfolge mit Azure Storage.

Hinweis

Ihr Speicherkontoschlüssel ähnelt dem Stammkennwort für das Speicherkonto. Achten Sie immer darauf, Ihren Speicherkontoschlüssel zu schützen. Vermeiden Sie die Verteilung an andere Benutzer, hartcodieren sie oder speichern Sie sie in einer Nur-Text-Datei, auf die andere Benutzer zugreifen können. Regenerieren Sie Ihren Schlüssel mithilfe des Azure-Portals, wenn Sie glauben, dass er kompromittiert wurde.

Die beste Möglichkeit zum Verwalten der Speicherverbindungszeichenfolge befindet sich in einer Konfigurationsdatei. Um die Verbindungszeichenfolge zu konfigurieren, öffnen Sie die app.config Datei im Projektmappen-Explorer in Visual Studio. Fügen Sie den Inhalt des hier gezeigten <appSettings> Elements hinzu. Ersetzen Sie connection-string durch den Wert, den Sie aus Ihrem Speicherkonto im Portal kopiert haben:

<configuration>
    <startup>
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>
    <appSettings>
        <add key="StorageConnectionString" value="connection-string" />
    </appSettings>
</configuration>

Ihre Konfigurationseinstellung sieht z. B. ähnlich wie in folgenden Beispielen aus:

<add key="StorageConnectionString" value="DefaultEndpointsProtocol=https;AccountName=storagesample;AccountKey=GMuzNHjlB3S9itqZJHHCnRkrokLkcSyW7yK9BRbGp0ENePunLPwBgpxV1Z/pVo9zpem/2xSHXkMqTHHLcx8XRA==EndpointSuffix=core.windows.net" />

Um auf den Azurite-Speicheremulator abzuzielen, können Sie eine Verknüpfung verwenden, die dem bekannten Kontonamen und dem Schlüssel zugeordnet ist. In diesem Fall lautet Ihre Einstellung der Verbindungszeichenfolge:

<add key="StorageConnectionString" value="UseDevelopmentStorage=true" />

Hinzufügen von using-Anweisungen

Fügen Sie die folgenden using Direktiven am Anfang der datei Program.cs hinzu:

using System; // Namespace for Console output
using System.Configuration; // Namespace for ConfigurationManager
using System.Threading.Tasks; // Namespace for Task
using Azure.Identity;
using Azure.Storage.Queues; // Namespace for Queue storage types
using Azure.Storage.Queues.Models; // Namespace for PeekedMessage

Erstellen des Warteschlangenspeicherclients

Mit der QueueClient-Klasse können Sie im Warteschlangenspeicher gespeicherte Warteschlangen abrufen. Hier ist eine Möglichkeit zum Erstellen des Dienstclients:

//-------------------------------------------------
// Create the queue service client
//-------------------------------------------------
public void CreateQueueClient(string queueName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to create and manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);
}

Tipp

Nachrichten, die Sie mithilfe der QueueClient-Klasse senden, müssen in einem Format vorliegen, das in einer XML-Anforderung mit UTF-8-Codierung enthalten sein kann. Optional können Sie die Option MessageEncoding- auf Base64- festlegen, um nicht kompatible Nachrichten zu verarbeiten.

Jetzt können Sie Code schreiben, der Daten ausliest und Daten in den Warteschlangenspeicher schreibt.

Warteschlange erstellen

In diesem Beispiel wird gezeigt, wie Sie eine Warteschlange erstellen:

//-------------------------------------------------
// Create a message queue
//-------------------------------------------------
public bool CreateQueue(string queueName)
{
    try
    {
        // Get the connection string from app settings
        string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

        // Instantiate a QueueClient which will be used to create and manipulate the queue
        QueueClient queueClient = new QueueClient(connectionString, queueName);

        // Create the queue
        queueClient.CreateIfNotExists();

        if (queueClient.Exists())
        {
            Console.WriteLine($"Queue created: '{queueClient.Name}'");
            return true;
        }
        else
        {
            Console.WriteLine($"Make sure the Azurite storage emulator running and try again.");
            return false;
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Exception: {ex.Message}\n\n");
        Console.WriteLine($"Make sure the Azurite storage emulator running and try again.");
        return false;
    }
}

Einfügen einer Nachricht in eine Warteschlange

Rufen Sie die SendMessage-Methode auf, um eine Nachricht in eine vorhandene Warteschlange einzufügen. Eine Nachricht kann entweder eine Zeichenfolge (im UTF-8-Format) oder ein Bytearray sein. Der folgende Code erstellt eine Warteschlange (sofern nicht vorhanden) und fügt eine Nachricht ein:

//-------------------------------------------------
// Insert a message into a queue
//-------------------------------------------------
public void InsertMessage(string queueName, string message)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to create and manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);

    // Create the queue if it doesn't already exist
    queueClient.CreateIfNotExists();

    if (queueClient.Exists())
    {
        // Send a message to the queue
        queueClient.SendMessage(message);
    }

    Console.WriteLine($"Inserted: {message}");
}

Vorschau auf die nächste Nachricht

Sie können die Nachrichten in der Warteschlange anzeigen, ohne sie aus der Warteschlange zu entfernen, indem Sie die PeekMessages-Methode aufrufen. Wenn Sie keinen Wert für den maxMessages-Parameter übergeben, besteht die Standardeinstellung darin, eine Nachricht anzuzeigen.

//-------------------------------------------------
// Peek at a message in the queue
//-------------------------------------------------
public void PeekMessage(string queueName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);

    if (queueClient.Exists())
    { 
        // Peek at the next message
        PeekedMessage[] peekedMessage = queueClient.PeekMessages();

        // Display the message
        Console.WriteLine($"Peeked message: '{peekedMessage[0].Body}'");
    }
}

Ändern des Inhalts einer in die Warteschlange eingereihten Nachricht

Sie können den Inhalt einer Nachricht direkt in der Warteschlange ändern. Wenn die Nachricht eine Arbeitsaufgabe darstellt, können Sie dieses Feature verwenden, um den Status der Arbeitsaufgabe zu aktualisieren. Der folgende Code aktualisiert die Warteschlangennachricht mit neuem Inhalt und legt das Zeitlimit für die Sichtbarkeit fest, um weitere 60 Sekunden zu verlängern. Dadurch wird der Arbeitsstatus gespeichert, der der Nachricht zugeordnet ist, und dem Client wird eine weitere Minute zugewiesen, um mit der Arbeit an der Nachricht fortzufahren. Sie können diese Technik verwenden, um mehrstufige Workflows in Warteschlangennachrichten nachzuverfolgen, ohne von Anfang an zu beginnen, wenn ein Verarbeitungsschritt aufgrund von Hardware- oder Softwarefehlern fehlschlägt. Normalerweise würden Sie auch eine Wiederholungsanzahl beibehalten, und wenn die Nachricht mehr als n Mal wiederholt wird, würden Sie sie löschen. Dadurch wird vor einer Meldung geschützt, die bei jeder Verarbeitung einen Anwendungsfehler auslöst.

//-------------------------------------------------
// Update an existing message in the queue
//-------------------------------------------------
public void UpdateMessage(string queueName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);

    if (queueClient.Exists())
    {
        // Get the message from the queue
        QueueMessage[] message = queueClient.ReceiveMessages();

        // Update the message contents
        queueClient.UpdateMessage(message[0].MessageId, 
                message[0].PopReceipt, 
                "Updated contents",
                TimeSpan.FromSeconds(60.0)  // Make it invisible for another 60 seconds
            );
    }
}

Entfernen der nächsten Nachricht aus der Warteschlange

Entfernen Sie eine Nachricht aus einer Warteschlange in zwei Schritten. Wenn Sie ReceiveMessagesanrufen, wird die nächste Nachricht in einer Warteschlange angezeigt. Eine von ReceiveMessages zurückgegebene Nachricht wird für alle anderen Codelesenachrichten aus dieser Warteschlange unsichtbar. Diese Nachricht bleibt standardmäßig 30 Sekunden lang unsichtbar. Um das Entfernen der Nachricht aus der Warteschlange abzuschließen, müssen Sie auch DeleteMessageanrufen. Dieser zweistufige Prozess bei der Verarbeitung einer Nachricht stellt sicher, dass, wenn Ihr Code aufgrund von Hardware- oder Softwarefehlern eine Nachricht nicht verarbeiten kann, eine andere Instanz Ihres Codes dieselbe Nachricht abrufen und es erneut versuchen kann. Ihr Code ruft DeleteMessage direkt nach der Verarbeitung der Nachricht auf.

//-------------------------------------------------
// Process and remove a message from the queue
//-------------------------------------------------
public void DequeueMessage(string queueName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);

    if (queueClient.Exists())
    {
        // Get the next message
        QueueMessage[] retrievedMessage = queueClient.ReceiveMessages();

        // Process (i.e. print) the message in less than 30 seconds
        Console.WriteLine($"Dequeued message: '{retrievedMessage[0].Body}'");

        // Delete the message
        queueClient.DeleteMessage(retrievedMessage[0].MessageId, retrievedMessage[0].PopReceipt);
    }
}

Verwenden Sie das Async-Await-Muster mit allgemeinen Warteschlangenspeicher-APIs

In diesem Beispiel wird gezeigt, wie Sie das Async-Await Muster mit allgemeinen Warteschlangenspeicher-APIs verwenden. Im Beispiel wird die asynchrone Version der einzelnen Methoden aufgerufen, wie durch das Async Suffix jeder Methode angegeben. Wenn eine asynchrone Methode verwendet wird, hält das Async-Await Muster die lokale Ausführung an, bis der Aufruf abgeschlossen ist. Dieses Verhalten ermöglicht es dem aktuellen Thread, andere Aufgaben zu erledigen, wodurch Leistungsengpässe vermieden und die Gesamtreaktionsfähigkeit Ihrer Anwendung verbessert wird. Weitere Informationen zur Verwendung des Async-Await-Musters in .NET finden Sie unter Async and Await (C# und Visual Basic)

//-------------------------------------------------
// Perform queue operations asynchronously
//-------------------------------------------------
public async Task QueueAsync(string queueName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);

    // Create the queue if it doesn't already exist
    await queueClient.CreateIfNotExistsAsync();

    if (await queueClient.ExistsAsync())
    {
        Console.WriteLine($"Queue '{queueClient.Name}' created");
    }
    else
    {
        Console.WriteLine($"Queue '{queueClient.Name}' exists");
    }

    // Async enqueue the message
    await queueClient.SendMessageAsync("Hello, World");
    Console.WriteLine($"Message added");

    // Async receive the message
    QueueMessage[] retrievedMessage = await queueClient.ReceiveMessagesAsync();
    Console.WriteLine($"Retrieved message with content '{retrievedMessage[0].Body}'");

    // Async delete the message
    await queueClient.DeleteMessageAsync(retrievedMessage[0].MessageId, retrievedMessage[0].PopReceipt);
    Console.WriteLine($"Deleted message: '{retrievedMessage[0].Body}'");

    // Async delete the queue
    await queueClient.DeleteAsync();
    Console.WriteLine($"Deleted queue: '{queueClient.Name}'");
}

Verwenden zusätzlicher Optionen zum Entfernen von Nachrichten

Es gibt zwei Möglichkeiten zum Anpassen des Nachrichtenabrufs aus einer Warteschlange. Zunächst können Sie eine Reihe von Nachrichten (bis zu 32) abrufen. Zweitens können Sie eine längere oder kürzere Unsichtbarkeitszeit einstellen, sodass Ihr Code mehr oder weniger Zeit hat, jede Nachricht vollständig zu verarbeiten.

Im folgenden Codebeispiel wird die ReceiveMessages-Methode verwendet, um 20 Nachrichten in einem Aufruf abzurufen. Anschließend verarbeitet sie jede Nachricht mithilfe einer foreach Schleife. Außerdem wird für jede Nachricht das Timeout für die Unsichtbarkeit auf fünf Minuten festgelegt. Beachten Sie, dass die fünf Minuten für alle Nachrichten gleichzeitig gestartet werden, sodass nach fünf Minuten seit dem Anruf an ReceiveMessagesalle Nachrichten, die nicht gelöscht wurden, wieder sichtbar werden.

//-----------------------------------------------------
// Process and remove multiple messages from the queue
//-----------------------------------------------------
public void DequeueMessages(string queueName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);

    if (queueClient.Exists())
    {
        // Receive and process 20 messages
        QueueMessage[] receivedMessages = queueClient.ReceiveMessages(20, TimeSpan.FromMinutes(5));

        foreach (QueueMessage message in receivedMessages)
        {
            // Process (i.e. print) the messages in less than 5 minutes
            Console.WriteLine($"De-queued message: '{message.Body}'");

            // Delete the message
            queueClient.DeleteMessage(message.MessageId, message.PopReceipt);
        }
    }
}

Warteschlangenlänge abrufen

Sie können die Anzahl der Nachrichten in einer Warteschlange schätzen lassen. Die Methode GetProperties gibt Warteschlangeneigenschaften einschließlich der Nachrichtenanzahl zurück. Die ApproximateMessagesCount-Eigenschaft enthält die ungefähre Anzahl der Nachrichten in der Warteschlange. Diese Zahl ist nicht niedriger als die tatsächliche Anzahl von Nachrichten in der Warteschlange, kann aber höher sein.

//-----------------------------------------------------
// Get the approximate number of messages in the queue
//-----------------------------------------------------
public void GetQueueLength(string queueName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);

    if (queueClient.Exists())
    {
        QueueProperties properties = queueClient.GetProperties();

        // Retrieve the cached approximate message count.
        int cachedMessagesCount = properties.ApproximateMessagesCount;

        // Display number of messages.
        Console.WriteLine($"Number of messages in queue: {cachedMessagesCount}");
    }
}

Eine Warteschlange löschen

Um eine Warteschlange und alle darin enthaltenen Nachrichten zu löschen, rufen Sie die Delete-Methode für das Warteschlangenobjekt auf.

//-------------------------------------------------
// Delete the queue
//-------------------------------------------------
public void DeleteQueue(string queueName)
{
    // Get the connection string from app settings
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

    // Instantiate a QueueClient which will be used to manipulate the queue
    QueueClient queueClient = new QueueClient(connectionString, queueName);

    if (queueClient.Exists())
    {
        // Delete the queue
        queueClient.Delete();
    }

    Console.WriteLine($"Queue deleted: '{queueClient.Name}'");
}

Nächste Schritte

Nachdem Sie nun die Grundlagen des Warteschlangenspeichers kennengelernt haben, folgen Sie diesen Links, um mehr über komplexere Speicheraufgaben zu erfahren.

Verwandte Code-Beispiele mithilfe veralteter SDKs der .NET-Version 11.x finden Sie unter Code-Beispiele mithilfe der .NET-Version 11.x.