Introducción a las colas de Service BusGet started with Service Bus queues

En este tutorial, creará aplicaciones de consola de .NET Core para enviar mensajes a una cola de Service Bus y recibir mensajes desde ella.In this tutorial, you create .NET Core console applications to send messages to and receive messages from a Service Bus queue.

Requisitos previosPrerequisites

  1. Visual Studio 2017 Update 3 (versión 15.3, 26730.01) o posterior.Visual Studio 2017 Update 3 (version 15.3, 26730.01) or later.
  2. NET Core SDK, versión 2.0 o posterior.NET Core SDK, version 2.0 or later.
  3. Una suscripción de Azure.An Azure subscription. Para completar este tutorial, deberá tener una cuenta de Azure.To complete this tutorial, you need an Azure account. Puede activar sus ventajas de suscriptor a MSDN o registrarse para obtener una cuenta gratuita.You can activate your MSDN subscriber benefits or sign up for a free account.
  4. Si no tiene una cola con la que trabajar, siga los pasos del artículo Uso de Azure Portal para crear una cola de Service Bus para crear una.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. Lea la introducción rápida de las colas de Service Bus.Read the quick overview of Service Bus queues.
    2. Cree un espacio de nombres de Service Bus.Create a Service Bus namespace.
    3. Obtenga la cadena de conexión.Get the connection string.
    4. Cree una cola de Service Bus.Create a Service Bus queue.

Envío de mensajes a la colaSend messages to the queue

Para enviar mensajes a la cola, escriba una aplicación de consola en C# mediante Visual Studio.To send messages to the queue, write a C# console application using Visual Studio.

Creación de una aplicación de consolaCreate a console application

Inicie Visual Studio y cree un nuevo proyecto Aplicación de consola (.NET Core) .Launch Visual Studio and create a new Console App (.NET Core) project.

Agregar el paquete NuGet de Service BusAdd the Service Bus NuGet package

  1. Haga clic con el botón derecho en el proyecto recién creado y seleccione Administrar paquetes NuGet.Right-click the newly created project and select Manage NuGet Packages.

  2. Haga clic en la pestaña Examinar, busque Microsoft.Azure.ServiceBus y seleccione el elemento WindowsAzure.ServiceBus.Click the Browse tab, search for Microsoft.Azure.ServiceBus, and then select the Microsoft.Azure.ServiceBus item. Haga clic en Instalar para completar la instalación y, a continuación, cierre este cuadro de diálogo.Click Install to complete the installation, then close this dialog box.

    Seleccionar un paquete NuGet

Escritura del código para enviar mensajes a la colaWrite code to send messages to the queue

  1. En Program.cs, agregue las siguientes instrucciones using en la parte superior de la definición del espacio de nombres, antes de la declaración de clase: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. En la clase Program, declare las variables siguientes.Within the Program class, declare the following variables. Establezca la variable ServiceBusConnectionString en la cadena de conexión que obtuvo al crear el espacio de nombres y establezca QueueName en el nombre que usó cuando creó la cola: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. Reemplace el contenido predeterminado de Main() con la siguiente línea de código:Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Directamente después de Main(), agregue el siguiente método MainAsync() asincrónico que llama al método para enviar mensajes: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. Directamente después del método MainAsync(), agregue el siguiente método SendMessagesAsync() que realiza el trabajo de enviar el número de mensajes especificado por numberOfMessagesToSend (actualmente se establece en 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. Así debería ser el archivo Program.cs.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. Ejecute el programa y compruebe Azure Portal: haga clic en el nombre de la cola en la hoja Información general del espacio de nombres.Run the program, and check the Azure portal: click the name of your queue in the namespace Overview window. Se muestra la pantalla Essentials de la cola.The queue Essentials screen is displayed. Tenga en cuenta que el valor de Recuento de mensajes activos es ahora 10.Notice that the Active Message Count value for the queue is now 10. Cada vez que se ejecuta la aplicación de remitente sin recuperar los mensajes (como se describe en la siguiente sección), este valor aumenta en 10.Each time you run the sender application without retrieving the messages (as described in the next section), this value increases by 10. Tenga en cuenta también que el tamaño actual de la cola aumenta el valor de Actual en la ventana Essentials cada vez que la aplicación agrega mensajes a la cola.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.

    Tamaño del mensaje

Recepción de mensajes de la colaReceive messages from the queue

Para recibir los mensajes que envió, cree otra aplicación de consola de .NET Core e instale el paquete NuGet Microsoft.Azure.ServiceBus, similar a la aplicación de remitente anterior.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.

Escritura de código para recibir mensajes de la colaWrite code to receive messages from the queue

  1. En Program.cs, agregue las siguientes instrucciones using en la parte superior de la definición del espacio de nombres, antes de la declaración de clase: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. En la clase Program, declare las variables siguientes.Within the Program class, declare the following variables. Establezca la variable ServiceBusConnectionString en la cadena de conexión que obtuvo al crear el espacio de nombres y establezca QueueName en el nombre que usó cuando creó la cola: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. Reemplace el contenido predeterminado de Main() con la siguiente línea de código:Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Directamente después de Main(), agregue el siguiente método MainAsync() asincrónico que llama al método 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. Directamente después del método MainAsync(), agregue el método siguiente que registra el controlador de mensajes y recibe los mensajes enviados por la aplicación remitente: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. Directamente después del método anterior, agregue el siguiente método ProcessMessagesAsync() para procesar los mensajes recibidos: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. Por último, agregue el siguiente método para controlar las excepciones que pueden producirse: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. Este es el aspecto que debería tener el archivo Program.cs: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. Ejecute el programa y vuelva a comprobar el portal.Run the program, and check the portal again. Tenga en cuenta que los valores de Recuento de mensajes activos y Actual ahora son 0.Notice that the Active Message Count and Current values are now 0.

    Longitud de la cola

Felicidades.Congratulations! Ahora ha creado una cola, ha enviado un mensaje a dicha cola y ha recibido esos mensajes de la misma cola.You have now created a queue, sent a set of messages to that queue, and received those messages from the same queue.

Nota

Puede administrar los recursos de Service Bus con el Explorador de Service Bus.You can manage Service Bus resources with Service Bus Explorer. El Explorador de Service Bus permite a los usuarios conectarse a un espacio de nombres de Service Bus y administrar las entidades de mensajería de una forma sencilla.The Service Bus Explorer allows users to connect to a Service Bus namespace and administer messaging entities in an easy manner. La herramienta dispone de características avanzadas, como la funcionalidad de importación y exportación o la capacidad de probar el tema, las colas, las suscripciones, los servicios de retransmisión, los centros de notificaciones y los centros de eventos.The tool provides advanced features like import/export functionality or the ability to test topic, queues, subscriptions, relay services, notification hubs and events hubs.

Pasos siguientesNext steps

Consulte nuestro repositorio de GitHub con ejemplos, donde se muestran algunas de las características más avanzadas de la mensajería de Service Bus.Check out our GitHub repository with samples that demonstrate some of the more advanced features of Service Bus messaging.