Erste Schritte mit Service Bus-WarteschlangenGet started with Service Bus queues

In diesem Tutorial erstellen Sie .NET Core-Konsolenanwendungen, um Nachrichten an eine Service Bus-Warteschlange zu senden und Antworten zu empfangen.In this tutorial, you create .NET Core console applications to send messages to and receive messages from a Service Bus queue.

VoraussetzungenPrerequisites

  1. Visual Studio 2017 Update 3 (Version 15.3, 26730.01) oder höherVisual Studio 2017 Update 3 (version 15.3, 26730.01) or later.
  2. NET Core SDK ab Version 2.0NET Core SDK, version 2.0 or later.
  3. Ein Azure-Abonnement.An Azure subscription. Um dieses Tutorial abzuschließen, benötigen Sie ein Azure-Konto.To complete this tutorial, you need an Azure account. Sie können Ihre MSDN-Abonnentenvorteile aktivieren oder sich für ein kostenloses Konto registrieren.You can activate your MSDN subscriber benefits or sign up for a free account.
  4. Wenn Sie über keine Warteschlange verfügen, führen Sie die Schritte im Artikel Schnellstart: Erstellen einer Service Bus-Warteschlange mithilfe des Azure-Portals aus, um eine Warteschlange zu erstellen.If you don't have a queue to work with, follow steps in the Use Azure portal to create a Service Bus queue article to create a queue.
    1. Lesen Sie die kurze Übersicht über Service Bus-Warteschlangen.Read the quick overview of Service Bus queues.
    2. Erstellen Sie einen Service Bus-Namespace.Create a Service Bus namespace.
    3. Rufen Sie die Verbindungszeichenfolge ab.Get the connection string.
    4. Erstellen Sie eine Service Bus-Warteschlange.Create a Service Bus queue.

Senden von Nachrichten an die WarteschlangeSend messages to the queue

Erstellen Sie mithilfe von Visual Studio eine C#-Konsolenanwendung, um Nachrichten an die Warteschlange senden zu können.To send messages to the queue, write a C# console application using Visual Studio.

Erstellen einer KonsolenanwendungCreate a console application

Starten Sie Visual Studio, und erstellen Sie ein neues Projekt vom Typ Konsolen-App (.NET Core) .Launch Visual Studio and create a new Console App (.NET Core) project.

Hinzufügen des NuGet-Pakets "Service Bus"Add the Service Bus NuGet package

  1. Klicken Sie mit der rechten Maustaste auf das neu erstellte Projekt, und wählen Sie NuGet-Pakete verwalten aus.Right-click the newly created project and select Manage NuGet Packages.

  2. Klicken Sie auf die Registerkarte Durchsuchen, suchen Sie nach Microsoft.Azure.ServiceBus , und wählen Sie anschließend das Element Microsoft.Azure.ServiceBus aus.Click the Browse tab, search for Microsoft.Azure.ServiceBus, and then select the Microsoft.Azure.ServiceBus item. Klicken Sie auf Installieren, um die Installation abzuschließen. Schließen Sie danach dieses Dialogfeld.Click Install to complete the installation, then close this dialog box.

    Auswählen eines NuGet-Pakets

Schreiben von Code für das Senden von Nachrichten an die WarteschlangeWrite code to send messages to the queue

  1. Fügen Sie in „Program.cs“ am Beginn der Namespacedefinition die folgenden using-Anweisungen vor der Klassendeklaration hinzu:In Program.cs, add the following using statements at the top of the namespace definition, before the class declaration:

    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.ServiceBus;
    
  2. Deklarieren Sie innerhalb der Klasse Program die folgenden Variablen.Within the Program class, declare the following variables. Legen Sie die Variable ServiceBusConnectionString auf die Verbindungszeichenfolge fest, die Sie beim Erstellen des Namespace erhalten haben, und QueueName auf den Namen, den Sie beim Erstellen der Warteschlange verwendet haben:Set the ServiceBusConnectionString variable to the connection string that you obtained when creating the namespace, and set QueueName to the name that you used when creating the queue:

    const string ServiceBusConnectionString = "<your_connection_string>";
    const string QueueName = "<your_queue_name>";
    static IQueueClient queueClient;
    
  3. Ersetzen Sie den Standardinhalt von Main() durch die folgende Codezeile:Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Fügen Sie direkt nach Main() die folgende asynchrone MainAsync()-Methode hinzu, die die Methode für den Nachrichtenversand aufruft:Directly after Main(), add the following asynchronous MainAsync() method that calls the send messages method:

    static async Task MainAsync()
    {
        const int numberOfMessages = 10;
        queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
        Console.WriteLine("======================================================");
        Console.WriteLine("Press ENTER key to exit after sending all the messages.");
        Console.WriteLine("======================================================");
    
        // Send messages.
        await SendMessagesAsync(numberOfMessages);
    
        Console.ReadKey();
    
        await queueClient.CloseAsync();
    }
    
  5. Fügen Sie direkt nach der MainAsync()-Methode die folgende SendMessagesAsync()-Methode hinzu. Diese Methode dient zum Senden der durch numberOfMessagesToSend angegebenen Anzahl von Nachrichten. Die Anzahl ist aktuell auf 10 festgelegt:Directly after the MainAsync() method, add the following SendMessagesAsync() method that performs the work of sending the number of messages specified by numberOfMessagesToSend (currently set to 10):

    static async Task SendMessagesAsync(int numberOfMessagesToSend)
    {
        try
        {
            for (var i = 0; i < numberOfMessagesToSend; i++)
            {
                // Create a new message to send to the queue.
                string messageBody = $"Message {i}";
                var message = new Message(Encoding.UTF8.GetBytes(messageBody));
    
                // Write the body of the message to the console.
                Console.WriteLine($"Sending message: {messageBody}");
    
                // Send the message to the queue.
                await queueClient.SendAsync(message);
            }
        }
        catch (Exception exception)
        {
            Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
        }
    }
    
  6. Die Datei „Program.cs“ sollte nun wie folgt aussehen:Here is what your Program.cs file should look like.

    namespace CoreSenderApp
    {
        using System;
        using System.Text;
        using System.Threading;
        using System.Threading.Tasks;
        using Microsoft.Azure.ServiceBus;
    
        class Program
        {
            // Connection String for the namespace can be obtained from the Azure portal under the 
            // 'Shared Access policies' section.
            const string ServiceBusConnectionString = "<your_connection_string>";
            const string QueueName = "<your_queue_name>";
            static IQueueClient queueClient;
    
            static void Main(string[] args)
            {
                MainAsync().GetAwaiter().GetResult();
            }
    
            static async Task MainAsync()
            {
                const int numberOfMessages = 10;
                queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
                Console.WriteLine("======================================================");
                Console.WriteLine("Press ENTER key to exit after sending all the messages.");
                Console.WriteLine("======================================================");
    
                // Send Messages
                await SendMessagesAsync(numberOfMessages);
    
                Console.ReadKey();
    
                await queueClient.CloseAsync();
            }
    
            static async Task SendMessagesAsync(int numberOfMessagesToSend)
            {
                try
                {
                    for (var i = 0; i < numberOfMessagesToSend; i++)
                    {
                        // Create a new message to send to the queue
                        string messageBody = $"Message {i}";
                        var message = new Message(Encoding.UTF8.GetBytes(messageBody));
    
                        // Write the body of the message to the console
                        Console.WriteLine($"Sending message: {messageBody}");
    
                        // Send the message to the queue
                        await queueClient.SendAsync(message);
                    }
                }
                catch (Exception exception)
                {
                    Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
                }
            }
        }
    }
    
  7. Führen Sie das Programm aus, und prüfen Sie im Azure-Portal Folgendes: Klicken Sie im Fenster Übersicht auf den Namen Ihrer Warteschlange im Namespace.Run the program, and check the Azure portal: click the name of your queue in the namespace Overview window. Für die Warteschlange wird der Bildschirm Zusammenfassung angezeigt.The queue Essentials screen is displayed. Unter Anzahl aktiver Nachrichten ist für die Warteschlange nun der Wert 10 angegeben.Notice that the Active Message Count value for the queue is now 10. Jedes Mal, wenn Sie die Absenderanwendung ausführen, ohne die Nachrichten abzurufen (wie im nächsten Abschnitt beschrieben), erhöht sich dieser Wert um 10.Each time you run the sender application without retrieving the messages (as described in the next section), this value increases by 10. Beachten Sie auch, dass sich bei der aktuellen Warteschlangengröße der Wert Aktuell im Fenster Zusammenfassung jeweils erhöht, wenn der Warteschlange durch die App Nachrichten hinzugefügt werden.Also note that the current size of the queue increments the Current value in the Essentials window each time the app adds messages to the queue.

    Nachrichtengröße

Empfangen von Nachrichten aus der WarteschlangeReceive messages from the queue

Erstellen Sie zum Empfangen der gesendeten Nachrichten eine weitere .NET Core-Konsolenanwendung, und installieren Sie das NuGet-Paket Microsoft.Azure.ServiceBus. Die Vorgehensweise ist dabei ähnlich wie bei der Absenderanwendung.To receive the messages you sent, create another .NET Core console application and install the Microsoft.Azure.ServiceBus NuGet package, similar to the previous sender application.

Schreiben von Code für das Empfangen von Nachrichten aus der WarteschlangeWrite code to receive messages from the queue

  1. Fügen Sie in „Program.cs“ am Beginn der Namespacedefinition die folgenden using-Anweisungen vor der Klassendeklaration hinzu:In Program.cs, add the following using statements at the top of the namespace definition, before the class declaration:

    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.ServiceBus;
    
  2. Deklarieren Sie innerhalb der Klasse Program die folgenden Variablen.Within the Program class, declare the following variables. Legen Sie die Variable ServiceBusConnectionString auf die Verbindungszeichenfolge fest, die Sie beim Erstellen des Namespace erhalten haben, und QueueName auf den Namen, den Sie beim Erstellen der Warteschlange verwendet haben:Set the ServiceBusConnectionString variable to the connection string that you obtained when creating the namespace, and set QueueName to the name that you used when creating the queue:

    const string ServiceBusConnectionString = "<your_connection_string>";
    const string QueueName = "<your_queue_name>";
    static IQueueClient queueClient;
    
  3. Ersetzen Sie den Standardinhalt von Main() durch die folgende Codezeile:Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Fügen Sie direkt nach Main() die folgende asynchrone MainAsync()-Methode hinzu, die die RegisterOnMessageHandlerAndReceiveMessages()-Methode aufruft:Directly after Main(), add the following asynchronous MainAsync() method that calls the RegisterOnMessageHandlerAndReceiveMessages() method:

    static async Task MainAsync()
    {
        queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
        Console.WriteLine("======================================================");
        Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
        Console.WriteLine("======================================================");
    
        // Register the queue message handler and receive messages in a loop
        RegisterOnMessageHandlerAndReceiveMessages();
    
        Console.ReadKey();
    
        await queueClient.CloseAsync();
    }
    
  5. Fügen Sie direkt nach der MainAsync()-Methode die folgende Methode hinzu, die den Nachrichtenhandler registriert und die von der Absenderanwendung gesendeten Nachrichten empfängt:Directly after the MainAsync() method, add the following method that registers the message handler and receives the messages sent by the sender application:

    static void RegisterOnMessageHandlerAndReceiveMessages()
    {
        // Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
        var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
        {
            // Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
            // Set it according to how many messages the application wants to process in parallel.
            MaxConcurrentCalls = 1,
    
            // Indicates whether the message pump should automatically complete the messages after returning from user callback.
            // False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync().
            AutoComplete = false
        };
    
        // Register the function that processes messages.
        queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
    }
    
  6. Fügen Sie direkt nach der vorherigen Methode die folgende ProcessMessagesAsync()-Methode für die Verarbeitung der empfangenen Nachrichten hinzu:Directly after the previous method, add the following ProcessMessagesAsync() method to process the received messages:

    static async Task ProcessMessagesAsync(Message message, CancellationToken token)
    {
        // Process the message.
        Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
    
        // Complete the message so that it is not received again.
        // This can be done only if the queue Client is created in ReceiveMode.PeekLock mode (which is the default).
        await queueClient.CompleteAsync(message.SystemProperties.LockToken);
    
        // Note: Use the cancellationToken passed as necessary to determine if the queueClient has already been closed.
        // If queueClient has already been closed, you can choose to not call CompleteAsync() or AbandonAsync() etc.
        // to avoid unnecessary exceptions.
    }
    
  7. Fügen Sie abschließend die folgende Methode zur Behandlung möglicherweise auftretender Ausnahmen hinzu:Finally, add the following method to handle any exceptions that might occur:

    // Use this handler to examine the exceptions received on the message pump.
    static Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)
    {
        Console.WriteLine($"Message handler encountered an exception {exceptionReceivedEventArgs.Exception}.");
        var context = exceptionReceivedEventArgs.ExceptionReceivedContext;
        Console.WriteLine("Exception context for troubleshooting:");
        Console.WriteLine($"- Endpoint: {context.Endpoint}");
        Console.WriteLine($"- Entity Path: {context.EntityPath}");
        Console.WriteLine($"- Executing Action: {context.Action}");
        return Task.CompletedTask;
    }    
    
  8. Die Datei „Program.cs“ sollte nun wie folgt aussehen:Here is what your Program.cs file should look like:

    namespace CoreReceiverApp
    {
        using System;
        using System.Text;
        using System.Threading;
        using System.Threading.Tasks;
        using Microsoft.Azure.ServiceBus;
    
        class Program
        {
            // Connection String for the namespace can be obtained from the Azure portal under the 
            // 'Shared Access policies' section.
            const string ServiceBusConnectionString = "<your_connection_string>";
            const string QueueName = "<your_queue_name>";
            static IQueueClient queueClient;
    
            static void Main(string[] args)
            {
                MainAsync().GetAwaiter().GetResult();
            }
    
            static async Task MainAsync()
            {
                queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
                Console.WriteLine("======================================================");
                Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
                Console.WriteLine("======================================================");
    
                // Register QueueClient's MessageHandler and receive messages in a loop
                RegisterOnMessageHandlerAndReceiveMessages();
    
                Console.ReadKey();
    
                await queueClient.CloseAsync();
            }
    
            static void RegisterOnMessageHandlerAndReceiveMessages()
            {
                // Configure the MessageHandler Options in terms of exception handling, number of concurrent messages to deliver etc.
                var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
                {
                    // Maximum number of Concurrent calls to the callback `ProcessMessagesAsync`, set to 1 for simplicity.
                    // Set it according to how many messages the application wants to process in parallel.
                    MaxConcurrentCalls = 1,
    
                    // Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
                    // False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
                    AutoComplete = false
                };
    
                // Register the function that will process messages
                queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
            }
    
            static async Task ProcessMessagesAsync(Message message, CancellationToken token)
            {
                // Process the message
                Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
    
                // Complete the message so that it is not received again.
                // This can be done only if the queueClient is created in ReceiveMode.PeekLock mode (which is default).
                await queueClient.CompleteAsync(message.SystemProperties.LockToken);
    
                // Note: Use the cancellationToken passed as necessary to determine if the queueClient has already been closed.
                // If queueClient has already been Closed, you may chose to not call CompleteAsync() or AbandonAsync() etc. calls 
               // to avoid unnecessary exceptions.
            }
    
            static Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)
            {
                Console.WriteLine($"Message handler encountered an exception {exceptionReceivedEventArgs.Exception}.");
                var context = exceptionReceivedEventArgs.ExceptionReceivedContext;
                Console.WriteLine("Exception context for troubleshooting:");
                Console.WriteLine($"- Endpoint: {context.Endpoint}");
                Console.WriteLine($"- Entity Path: {context.EntityPath}");
                Console.WriteLine($"- Executing Action: {context.Action}");
                return Task.CompletedTask;
            }
        }
    }
    
  9. Führen Sie das Programm aus, und überprüfen Sie die Angaben im Portal erneut.Run the program, and check the portal again. Beachten Sie, dass die Werte für Anzahl aktiver Nachrichten und Aktuell jetzt 0 lauten.Notice that the Active Message Count and Current values are now 0.

    Warteschlangenlänge

Glückwunsch!Congratulations! Sie haben eine Warteschlange erstellt, eine Reihe von Nachrichten an diese Warteschlange gesendet und diese Nachrichten aus der Warteschlange empfangen.You have now created a queue, sent a set of messages to that queue, and received those messages from the same queue.

Hinweis

Sie können Service Bus-Ressourcen mit dem Service Bus-Explorer verwalten.You can manage Service Bus resources with Service Bus Explorer. Mit dem Service Bus-Explorer können Benutzer eine Verbindung mit einem Service Bus-Namespace herstellen und Messagingentitäten auf einfache Weise verwalten.The Service Bus Explorer allows users to connect to a Service Bus namespace and administer messaging entities in an easy manner. Das Tool stellt erweiterte Features wie Import-/Exportfunktionen oder Testmöglichkeiten für Themen, Warteschlangen, Abonnements, Relaydienste, Notification Hubs und Event Hubs zur Verfügung.The tool provides advanced features like import/export functionality or the ability to test topic, queues, subscriptions, relay services, notification hubs and events hubs.

Nächste SchritteNext steps

Sehen Sie sich das GitHub-Repository mit Beispielen an, mit denen einige erweiterte Features des Service Bus Messaging veranschaulicht werden.Check out our GitHub repository with samples that demonstrate some of the more advanced features of Service Bus messaging.