Komma igång med Service Bus-köerGet started with Service Bus queues

I den här självstudien skapar du .NET Core-konsolprogram för att skicka meddelanden till och ta emot meddelanden från en Service Bus-kö.In this tutorial, you create .NET Core console applications to send messages to and receive messages from a Service Bus queue.

Nödvändiga komponenterPrerequisites

  1. Visual Studio 2017 Update 3 (version 15.3, 26730.01) eller senare.Visual Studio 2017 Update 3 (version 15.3, 26730.01) or later.
  2. NET Core SDK, version 2.0 eller senare.NET Core SDK, version 2.0 or later.
  3. En Azure-prenumeration.An Azure subscription. Du behöver ett Azure-konto för att slutföra den här självstudien.To complete this tutorial, you need an Azure account. Du kan aktivera din MSDN-prenumerantförmåner eller registrera dig för en kostnadsfritt konto.You can activate your MSDN subscriber benefits or sign up for a free account.
  4. Om du inte har en kö för att arbeta med, Följ stegen i den Använd Azure portal för att skapa en Service Bus-kö artikeln om du vill skapa en kö.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. Läsa snabbstartsidan översikt i Service Bus köer.Read the quick overview of Service Bus queues.
    2. Skapa ett Service Bus namnområde.Create a Service Bus namespace.
    3. Hämta den anslutningssträngen.Get the connection string.
    4. Skapa ett Service Bus .Create a Service Bus queue.

Skicka meddelanden till könSend messages to the queue

Skriv ett C#-konsolprogram med Visual Studio för att skicka meddelanden till kön.To send messages to the queue, write a C# console application using Visual Studio.

Skapa ett konsolprogramCreate a console application

Starta Visual Studio och skapa ett nytt projekt: Konsolprogram (.NET Core).Launch Visual Studio and create a new Console App (.NET Core) project.

Lägga till Service Bus-NuGet-paketetAdd the Service Bus NuGet package

  1. Högerklicka på det nyskapade projektet och välj Hantera Nuget-paket.Right-click the newly created project and select Manage NuGet Packages.

  2. Klicka på fliken Bläddra, sök efter Microsoft.Azure.ServiceBus och markera posten Microsoft.Azure.ServiceBus.Click the Browse tab, search for Microsoft.Azure.ServiceBus, and then select the Microsoft.Azure.ServiceBus item. Klicka på Installera för att slutföra installationen och stäng sedan den här dialogrutan.Click Install to complete the installation, then close this dialog box.

    Välj ett NuGet-paket

Skriva kod för att skicka meddelanden till könWrite code to send messages to the queue

  1. I Program.cs lägger du till följande using-instruktioner överst i definitionen för namnområdet, före klassdeklarationen: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. I Program-klassen deklarerar du följande variabler.Within the Program class, declare the following variables. Ställ in variabeln ServiceBusConnectionString på den anslutningssträng du fick när du skapade namnområdet, och ställ in QueueName på namnet du använde när du skapade kön: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. Ersätt standardinnehållet i Main() med följande rad med kod:Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Direkt efter Main() lägger du till följande asynkrona MainAsync()-metod som anropar metoden för att skicka meddelanden: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. Direkt efter MainAsync()-metoden lägger du till följande SendMessagesAsync()-metod som utför uppgiften att skicka det antal meddelanden som anges av numberOfMessagesToSend (för närvarande inställd på 10):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. Så här bör filen Program.cs se ut: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. Kör programmet och kontrollera Azure Portal: klicka på köns namn på fönstret Översikt för namnområdet.Run the program, and check the Azure portal: click the name of your queue in the namespace Overview window. Skärmen Grundläggande för kön visas.The queue Essentials screen is displayed. Observera att Antal aktiva meddelanden för kön nu är 10.Notice that the Active Message Count value for the queue is now 10. Varje gång du kör sändningsprogrammet utan att hämta meddelanden (beskrivs i nästa avsnitt) ökar detta värde med 10.Each time you run the sender application without retrieving the messages (as described in the next section), this value increases by 10. Observera också att köns aktuella storlek ökar värdet Aktuell i fönstret Grundläggande varje gång programmet lägger till meddelanden i kön.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.

    Meddelandestorlek

Ta emot meddelanden från könReceive messages from the queue

Skapa en annan .NET Core-konsolprogram för att ta emot meddelanden som du har skickat och installera den Microsoft.Azure.ServiceBus NuGet-paketet, ungefär som i det tidigare sändningsprogrammet.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.

Skriva kod för att ta emot meddelanden från könWrite code to receive messages from the queue

  1. I Program.cs lägger du till följande using-instruktioner överst i definitionen för namnområdet, före klassdeklarationen: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. I Program-klassen deklarerar du följande variabler.Within the Program class, declare the following variables. Ställ in variabeln ServiceBusConnectionString på den anslutningssträng du fick när du skapade namnområdet, och ställ in QueueName på namnet du använde när du skapade kön: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. Ersätt standardinnehållet i Main() med följande rad med kod:Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Direkt efter Main() lägger du till följande asynkrona MainAsync()-metod som anropar metoden RegisterOnMessageHandlerAndReceiveMessages():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. Direkt efter MainAsync()-metoden lägger du till följande metod som registrerar meddelandehanteraren och tar emot meddelanden som skickas av sändningsprogrammet: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. Direkt efter den föregående metoden lägger du till följande ProcessMessagesAsync()-metod för att bearbeta de mottagna meddelandena: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. Slutligen lägger du till följande metod för att hantera alla undantag som kan uppstå: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. Så här bör din Program.cs-fil se ut: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. Kör programmet och kontrollera portalen igen.Run the program, and check the portal again. Observera att värdena för Antal aktiva meddelanden och Aktuell nu är 0.Notice that the Active Message Count and Current values are now 0.

    Kölängd

Grattis!Congratulations! Nu har du skapat en kö, skickat en uppsättning meddelanden till kön och tagit emot meddelandena från samma kö.You have now created a queue, sent a set of messages to that queue, and received those messages from the same queue.

Nästa stegNext steps

Kolla in våra GitHub-databaser med exempel som visar några av de mer avancerade funktionerna i meddelandetjänsten i Service Bus.Check out our GitHub repository with samples that demonstrate some of the more advanced features of Service Bus messaging.