Začínáme s frontami služby Service BusGet started with Service Bus queues

V tomto kurzu vytvoříte konzolové aplikace .NET Core pro posílání zpráv a přijímání zpráv z fronty Service Bus.In this tutorial, you create .NET Core console applications to send messages to and receive messages from a Service Bus queue.

PředpokladyPrerequisites

Zasílání zpráv do frontySend messages to the queue

Abychom mohli do fronty odesílat zprávy, napíšeme v sadě Visual Studio konzolovou aplikaci v jazyce C#.To send messages to the queue, write a C# console application using Visual Studio.

Vytvoření konzolové aplikaceCreate a console application

Spusťte Visual Studio a vytvořte nový projekt Konzolová aplikace (.NET Core) pro C#.Launch Visual Studio and create a new Console App (.NET Core) project for C#. V tomto příkladu se pojmenuje CoreSenderAppaplikace.This example names the app CoreSenderApp.

Přidání balíčku Service Bus NuGetAdd the Service Bus NuGet package

  1. Klikněte pravým tlačítkem na nově vytvořený projekt a vyberte možnost Spravovat balíčky NuGet.Right-click the newly created project and select Manage NuGet Packages.

  2. Vyberte Procházet.Select Browse. Vyhledejte a vyberte Microsoft. Azure. ServiceBus .Search for and select Microsoft.Azure.ServiceBus.

  3. Vyberte instalovat a dokončete instalaci a potom zavřete Správce balíčků NuGet.Select Install to complete the installation, then close the NuGet Package Manager.

    Výběr balíčku NuGet

Napsání kódu pro odesílání zpráv do frontyWrite code to send messages to the queue

  1. V program.cspřidejte následující příkazy using v horní části definice oboru názvů před deklaraci třídy: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. Ve třídě Program deklarovat následující proměnné:In the Program class, declare the following variables:

    const string ServiceBusConnectionString = "<your_connection_string>";
    const string QueueName = "<your_queue_name>";
    static IQueueClient queueClient;
    

    Jako proměnnou ServiceBusConnectionString zadejte připojovací řetězec pro obor názvů.Enter your connection string for the namespace as the ServiceBusConnectionString variable. Zadejte název fronty.Enter your queue name.

  3. Metodu Main() nahraďte následující asynchronní metodou Main.Replace the Main() method with the following async Main method. Volá metodu SendMessagesAsync, kterou přidáte v dalším kroku k odesílání zpráv do fronty.It calls the SendMessagesAsync method that you will add in the next step to send messages to the queue.

    public static async Task Main(string[] args)
    {    
        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();
    }
    
  4. Přímo za metodu MainAsync() přidejte následující metodu SendMessagesAsync(), která provede práci odesláním počtu zpráv určených numberOfMessagesToSend (aktuálně nastavené na hodnotu 10):Directly after the MainAsync() method, add the following SendMessagesAsync() method that does 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}");
        }
    }
    

Soubor program.cs by měl vypadat nějak takto: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;

        public static async Task Main(string[] args)
        {    
            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}");
            }
        }
    }
}

Spusťte program a ověřte Azure Portal.Run the program and check the Azure portal.

Vyberte název vaší fronty v okně Přehled oboru názvů, aby se zobrazila základní informace o frontě.Select the name of your queue in the namespace Overview window to display queue Essentials.

Přijaté zprávy s počtem a velikostí

Hodnota Počet aktivních zpráv pro tuto frontu je teď 10.The Active message count value for the queue is now 10. Pokaždé, když spustíte tuto aplikaci odesílatele bez načtení zpráv, se tato hodnota zvýší o 10.Each time you run this sender app without retrieving the messages, this value increases by 10.

Aktuální velikost fronty zvýší aktuální hodnotu v nástroji Essentials pokaždé, když aplikace přidá zprávy do fronty.The current size of the queue increments the CURRENT value in Essentials each time the app adds messages to the queue.

V další části se dozvíte, jak tyto zprávy načíst.The next section describes how to retrieve these messages.

Přijetí zpráv z frontyReceive messages from the queue

Pokud chcete přijímat zprávy, které jste odeslali, vytvořte další aplikaci Konzolová aplikace (.NET Core) .To receive the messages you sent, create another Console App (.NET Core) application. Nainstalujte balíček NuGet Microsoft. Azure. ServiceBus , stejně jako u aplikace odesílatele.Install the Microsoft.Azure.ServiceBus NuGet package, as you did for the sender application.

Napsání kódu pro příjem zpráv z frontyWrite code to receive messages from the queue

  1. V program.cspřidejte následující příkazy using v horní části definice oboru názvů před deklaraci třídy: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. Ve třídě Program deklarovat následující proměnné:In the Program class, declare the following variables:

    const string ServiceBusConnectionString = "<your_connection_string>";
    const string QueueName = "<your_queue_name>";
    static IQueueClient queueClient;
    

    Jako proměnnou ServiceBusConnectionString zadejte připojovací řetězec pro obor názvů.Enter your connection string for the namespace as the ServiceBusConnectionString variable. Zadejte název fronty.Enter your queue name.

  3. Nahraďte výchozí obsah metody Main() následujícím řádkem kódu:Replace the default contents of Main() with the following line of code:

    public static async Task Main(string[] args)
    {    
        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();
    }
    
  4. Přímo za metodu MainAsync() přidejte následující metodu, která zaregistruje popisovač zprávy a přijme zprávy odesílané aplikací odesílatele:Directly after the MainAsync() method, add the following method, which 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);
    }
    
  5. Přímo za předchozí metodu přidejte následující metodu ProcessMessagesAsync() pro zpracování přijatých zpráv: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.
    }
    
  6. Nakonec přidejte následující metodu, která zpracovává případné výjimky, ke kterým může dojít: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;
    }
    

Soubor program.cs by měl vypadat nějak takto: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;
        }
    }
}

Spusťte program a znovu se podívejte na portál.Run the program, and check the portal again. Počet aktivních zpráv a aktuální hodnoty jsou nyní 0.The Active message count and CURRENT values are now 0.

Zařadit do fronty po přijetí zpráv

Blahopřejeme!Congratulations! Nyní jste vytvořili frontu, do této fronty jste odeslali sadu zpráv a tyto zprávy přijali ze stejné fronty.You've now created a queue, sent a set of messages to that queue, and received those messages from the same queue.

Poznámka

Prostředky Service Bus můžete spravovat pomocí Service Bus Exploreru.You can manage Service Bus resources with Service Bus Explorer. Service Bus Explorer umožňuje uživatelům snadno se připojit k oboru názvů Service Bus a spravovat entity zasílání zpráv.The Service Bus Explorer allows users to easily connect to a Service Bus namespace and administer messaging entities. Tento nástroj poskytuje pokročilé funkce, jako jsou funkce importu a exportu, nebo možnost testovat témata, fronty, odběry, služby přenosu, centra oznámení a centra událostí.The tool provides advanced features like import/export functionality or the ability to test topics, queues, subscriptions, relay services, notification hubs, and event hubs.

Další krokyNext steps

Podívejte se na naše úložiště GitHub s ukázkami, které předvádějí některé pokročilejší funkce zasílání zpráv služby Service Bus.Check out our GitHub repository with samples that demonstrate some of the more advanced features of Service Bus messaging.