Aplicación de niveles múltiples .NET con colas de Azure Service Bus

Desarrollar para Microsoft Azure es muy sencillo con Visual Studio y el SDK de Azure para .NET gratis. Este tutorial lo guía por los pasos para crear una aplicación que usa varios recursos de Azure que se ejecutan en su entorno local.

Aprenderá lo siguiente:

  • Cómo habilitar el equipo para el desarrollo de Azure con una única descarga e instalación.
  • Cómo utilizar Visual Studio para desarrollar para Azure.
  • Cómo crear una aplicación de niveles múltiples en Azure mediante el uso de roles web y de trabajo.
  • Cómo comunicarse entre niveles mediante las colas de Service Bus.

Nota

Para completar este tutorial, deberá tener una cuenta de Azure. Puede activar sus beneficios de suscriptor a MSDN o registrarse para obtener una evaluación gratuita.

En este tutorial compilará y ejecutará la aplicación de niveles múltiples en un servicio en la nube de Azure. El front-end es un rol web de ASP.NET MVC y el back-end es un rol de trabajo que usa una cola de Service Bus. Puede crear la misma aplicación de niveles múltiples con el front-end como un proyecto web que se implementa en un sitio web de Azure en lugar de en un servicio en la nube. También puede probar el tutorial de aplicación híbrida en la nube/local .NET.

La siguiente captura de pantalla muestra la aplicación completada:

Application's Submit page

Información general del escenario: comunicación entre roles

Para enviar una orden para su procesamiento, el componente de la interfaz de usuario de front-end, que se ejecuta en el rol web, debe interactuar con la lógica del nivel intermedio que se ejecuta en el rol de trabajo. En ese ejemplo se utiliza la mensajería de Service Bus para la comunicación entre los niveles.

El uso de la mensajería de Service Bus entre los niveles de web e intermedio desacopla los dos componentes. Al contrario que en la mensajería directa (es decir, TCP o HTTP), el nivel web no se conecta directamente al nivel intermedio; por el contrario, inserta unidades de trabajo, como mensajes, en Service Bus, que los conserva de manera confiable hasta que el nivel intermedio esté preparado para consumirlas y procesarlas.

Service Bus ofrece dos entidades para admitir la mensajería asincrónica: colas y temas. Con las colas, cada mensaje enviado a la cola lo consume un único receptor. Los temas admiten el patrón de publicación/suscripción, en el cual cada mensaje publicado está disponible para una suscripción registrada con el tema. Cada suscripción mantiene lógicamente su propia cola de mensajes. Las suscripciones también se pueden configurar con reglas de filtro que restringen el conjunto de mensajes pasados a la cola de suscripción a aquellos que coinciden con el filtro. En este ejemplo se usan las colas de Service Bus.

Diagram showing the communication between the Web Role, Service Bus, and the Worker Role.

Este mecanismo de comunicación tiene varias ventajas sobre la mensajería directa:

  • Desacoplamiento temporal. Al usar el patrón de mensajería asincrónica, no es necesarios que los productores y consumidores estén en línea al mismo tiempo. Service Bus almacena los mensajes de manera confiable hasta que la parte consumidora esté lista para recibirlos. De esta forma, los componentes de la aplicación distribuida se pueden desconectar, ya sea voluntariamente, por ejemplo, para mantenimiento, o debido a un bloqueo del componente, sin que afecte al sistema en su conjunto. Es más, puede que la aplicación consumidora solo necesite estar en línea durante determinados períodos del día.

  • Nivelación de la carga. En muchas aplicaciones, la carga del sistema varía con el tiempo, mientras que el tiempo de procesamiento requerido para cada unidad de trabajo suele ser constante. La intermediación de productores y consumidores de mensajes con una cola implica que la aplicación consumidora (el trabajador) solo necesita ser aprovisionada para acomodar una carga promedio en lugar de una carga pico. La profundidad de la cola aumenta y se contrae a medida que varíe la carga entrante, lo que permite ahorrar dinero directamente en función de la cantidad de infraestructura requerida para dar servicio a la carga de la aplicación.

  • Equilibrio de carga. A medida que aumenta la carga, se pueden agregar más procesos de trabajo para que puedan leerse desde la cola. Cada mensaje se procesa únicamente por uno de los procesos de trabajo. Además, este equilibrio de carga basado en extracciones permite el uso óptimo de las máquinas de trabajo aunque estas difieran en términos de capacidad de procesamiento, ya que extraerán mensajes a su frecuencia máxima propia. Este patrón con frecuencia se denomina patrón de consumo de competidor.

    Diagram showing the communication between the Web Role, the Service Bus, and two Worker Roles.

En las secciones siguientes se explica el código que implementa esta arquitectura.

Requisitos previos

En este tutorial, usará la autenticación de Microsoft Entra para crear objetos ServiceBusClient y ServiceBusAdministrationClient. También usará DefaultAzureCredential; para usarlo, debe realizar los pasos siguientes que le permiten probar la aplicación localmente en un entorno de desarrollo.

  1. Registrar una aplicación en Microsoft Entra ID.
  2. Agregar la aplicación al rol Service Bus Data Owner.
  3. Establecer las variables de entorno AZURE-CLIENT-ID, AZURE-TENANT-ID y AZURE-CLIENT-SECRET. Para obtener instrucciones, consulte este artículo.

Para obtener una lista de los roles integrados de Service Bus, consulte Roles integrados de Azure para Service Bus.

Creación de un espacio de nombres

El primer paso consiste en crear un espacio de nombres y obtener una clave de Firma de acceso compartido (SAS) para dicho espacio de nombres. Un espacio de nombres proporciona un límite de aplicación para cada aplicación que se expone a través de Service Bus. El sistema genera una clave SAS cuando se crea un espacio de nombres. La combinación del espacio de nombres y la clave SAS proporciona las credenciales de Service Bus para autenticar el acceso a una aplicación.

Creación de un espacio de nombres en Azure Portal

Para empezar a usar entidades de mensajería de Service Bus en Azure, primero hay que crear un espacio de nombres con un nombre que sea único en Azure. Un espacio de nombres proporciona un contenedor de ámbito para los recursos de Service Bus (colas, temas, etc.) que están dentro de la aplicación.

Para crear un espacio de nombres:

  1. Inicie sesión en Azure Portal.

  2. Vaya a la páginaTodos los servicios.

  3. En la barra de navegación izquierda, seleccione Integración en la lista de categorías, mantenga el mouse sobre Service Bus, y a continuación, seleccione el botón + en el icono de Service Bus.

    Image showing selection of Create a resource, Integration, and then Service Bus in the menu.

  4. En la pestaña Datos básicos de la página Crear espacio de nombres, siga estos pasos:

    1. En Suscripción, elija la suscripción de Azure en la que se va a crear el espacio de nombres.

    2. En Grupo de recursos, elija un grupo de recursos existente en el que residirá el espacio de nombres o cree uno.

    3. Escriba nombre para el espacio de nombres. El nombre del espacio de nombres debe cumplir las siguientes convenciones de nomenclatura:

      • El nombre debe ser único en Azure. El sistema realiza la comprobación automáticamente para ver si el nombre está disponible.
      • La longitud del nombre es de 6 caracteres como mínimo y 50 como máximo.
      • El nombre solo puede contener letras, números, guiones "-".
      • El nombre debe comenzar con una letra y terminar con una letra o un número.
      • El nombre no termina con "-sb" o "-mgmt".
    4. En Ubicación, elija la región donde se debe hospedar el espacio de nombres.

    5. En Plan de tarifa, seleccione el plan de tarifa (Básico, Estándar o Prémium) del espacio de nombres. Para este inicio rápido, seleccione Estándar.

      Importante

      Si desea usar temas y suscripciones, elija Estándar o Premium. El plan de tarifas Básico no admite temas o suscripciones.

      Si ha seleccionado el plan de tarifa Prémium, especifique el número de unidades de mensajería. El plan Premium proporciona aislamiento de recursos en el nivel de CPU y memoria para que cada carga de trabajo se ejecute de forma aislada. Este contenedor de recursos se llama unidad de mensajería. A cada espacio de nombres prémium se le asigna al menos una unidad de mensajería. Puede seleccionar 1, 2, 4, 8 o 16 unidades de mensajería para cada espacio de nombres prémium de Service Bus. Para más información, consulte Mensajería prémium de Service Bus.

    6. En la parte inferior de la página, seleccione Revisar y crear.

      Image showing the Create a namespace page

    7. En la página Revisar y crear, examine la configuración y seleccione Crear.

  5. Una vez que la implementación del recurso sea correcta, seleccione Ir al recurso en la página de implementación.

    Image showing the deployment succeeded page with the Go to resource link.

  6. Verá la página principal del espacio de nombres de Service Bus.

    Image showing the home page of the Service Bus namespace created.

Obtención de la cadena de conexión al espacio de nombres (Azure Portal)

La creación un espacio de nombres genera automáticamente una directiva de firma de acceso compartido (SAS) inicial con claves principal y secundaria, y cadenas de conexión principal y secundaria en el que ambas conceden control total sobre todos los aspectos del espacio de nombres. Para obtener información acerca de cómo crear reglas adicionales con derechos más restringidos para remitentes y destinatarios normales, consulte Autenticación y autorización de Service Bus.

Un cliente puede usar la cadena de conexión para conectarse al espacio de nombres de Service Bus. Para copiar la cadena de conexión principal del espacio de nombres, siga estos pasos:

  1. En la página Espacio de nombres de Service Bus, seleccione Directivas de acceso compartido en el menú de la izquierda.

  2. En la página Directivas de acceso compartido, seleccione RootManageSharedAccessKey.

  3. En la ventana Directiva: RootManageSharedAccessKey, seleccione el botón Copiar que hay junto a Cadena de conexión principal para copiar la cadena de conexión en el Portapapeles para su uso posterior. Pegue este valor en el Bloc de notas o cualquier otra ubicación temporal.

    Screenshot shows an S A S policy called RootManageSharedAccessKey, which includes keys and connection strings.

    Puede usar esta página para copiar la clave principal, la clave secundaria, la cadena de conexión principal y la cadena de conexión secundaria.

Creación de un rol web

En esta sección, va a crear el front-end de la aplicación. En primer lugar, va a crear las páginas que mostrará la aplicación. Después, va a agregar el código que envía elementos a una cola de Service Bus y muestra información de estado sobre la cola.

Creación del proyecto

  1. Inicie Visual Studio con privilegios de administrador: haga clic con el botón derecho en el icono del programa Visual Studio y, después, seleccione Ejecutar como administrador. El Emulador de Azure Compute, descrito posteriormente en este artículo, requiere que se inicie Visual Studio con privilegios de administrador.

    En Visual Studio, en el menú Archivo, seleccione Nuevo y Proyecto.

  2. En la página Plantillas, siga estos pasos:

    1. Seleccione C# como lenguaje de programación.

    2. Seleccione Nube como tipo de proyecto.

    3. Seleccione Servicio en la nube de Azure.

    4. Seleccione Siguiente.

      Screenshot of the New Project dialog box with Cloud selected and Azure Cloud Service Visual C# highlighted and outlined in red.

  3. Asigne al proyecto el nombre MultiTierApp, seleccione la ubicación del proyecto y, a continuación, seleccione Crear.

    Specify project name.

  4. En la página Roles, haga doble clic en Rol web de ASP.NET y seleccione Aceptar.

    Select Web Role

  5. Mantenga el cursor sobre WebRole1 en Solución de servicio de nube de Azure, seleccione el icono de lápiz y cambie el nombre del rol web a FrontendWebRole. Después, seleccione Aceptar. (Asegúrese de que escribe "Frontend" con "e" minúscula, no "FrontEnd").

    Screenshot of the New Microsoft Azure Cloud Service dialog box with the solution renamed to FrontendWebRole.

  6. En el cuadro de diálogo Crear una aplicación web ASP.NET, seleccione MVC y, a continuación, Crear.

    Screenshot of the New ASP.NET Project dialog box with MVC highlighted and outlined in red and the Change Authentication option outlined in red.

  7. En el Explorador de soluciones, en el proyecto FrontendWebRole, haga clic con el botón derecho en Referencias y seleccione Administrar paquetes NuGet.

  8. Seleccione la pestaña Examinar y, después, busque Azure.Messaging.ServiceBus. Seleccione el paquete Azure.Messaging.ServiceBus, seleccione Instalar y acepte las condiciones de uso.

    Screenshot of the Manage NuGet Packages dialog box with the Azure.Messaging.ServiceBus highlighted and the Install option outlined in red.

    Tenga en cuenta que ahora se hace referencia a los ensamblados del cliente requeridos y que se han agregado algunos archivos de código nuevos.

  9. Siga los mismos pasos para agregar el paquete NuGet Azure.Identity al proyecto.

  10. En el Explorador de soluciones, expanda FronendWebRole, haga clic con el botón derecho en Modelos, seleccione Agregar y, después, Clase. En el cuadro Nombre, escriba el nombre OnlineOrder.cs. A continuación, seleccione Agregar.

Especificación del código del rol web

En esta sección, creará las distintas páginas que va a mostrar la aplicación.

  1. En el archivo OnlineOrder.cs en Visual Studio, sustituya la definición del espacio de nombres existentes por el código siguiente:

    namespace FrontendWebRole.Models
    {
        public class OnlineOrder
        {
            public string Customer { get; set; }
            public string Product { get; set; }
        }
    }
    
  2. En el Explorador de soluciones, haga doble clic en Controllers\HomeController.cs. Agregue las siguientes instrucciones using en la parte superior del archivo para incluir los espacios de nombres en el modelo que acaba de crear, así como Service Bus.

     using FrontendWebRole.Models;
     using Azure.Messaging.ServiceBus;    
    
  3. En el archivo HomeController.cs en Visual Studio, sustituya la definición del espacio de nombres existentes por el código siguiente. Este código contiene métodos para controlar el envío de elementos a la cola.

    namespace FrontendWebRole.Controllers
    {
        public class HomeController : Controller
        {
            public ActionResult Index()
            {
                // Simply redirect to Submit, since Submit will serve as the
                // front page of this application.
                return RedirectToAction("Submit");
            }
    
            public ActionResult About()
            {
                return View();
            }
    
            // GET: /Home/Submit.
            // Controller method for a view you will create for the submission
            // form.
            public ActionResult Submit()
            {
                // Will put code for displaying queue message count here.
    
                return View();
            }
    
            // POST: /Home/Submit.
            // Controller method for handling submissions from the submission
            // form.
            [HttpPost]
            // Attribute to help prevent cross-site scripting attacks and
            // cross-site request forgery.  
            [ValidateAntiForgeryToken]
            public ActionResult Submit(OnlineOrder order)
            {
                if (ModelState.IsValid)
                {
                    // Will put code for submitting to queue here.
    
                    return RedirectToAction("Submit");
                }
                else
                {
                    return View(order);
                }
            }
        }
    }
    
  4. En el menú Compilar, seleccione Compilar solución para probar la precisión del trabajo hasta ahora.

  5. Ahora, va a crear la vista para el método Submit() que creó antes. Haga clic con el botón derecho en el método Submit() (la sobrecarga de Submit() que no acepta parámetros) del archivo HomeController.cs y elija Agregar vista.

  6. En el cuadro de diálogo Agregar nuevo elemento con scaffolding, seleccione Agregar.

  7. En el cuadro de diálogo Agregar vista, siga estos pasos:

    1. En la lista Plantilla, elija Crear.

    2. En la lista Clase de modelo, seleccione la clase OnlineOrder.

    3. Seleccione Agregar.

      A screenshot of the Add View dialog box with the Template and Model class drop-down lists outlined in red.

  8. Ahora, cambie el nombre mostrado de la aplicación. En el Explorador de soluciones, haga doble clic en el archivo Views\Shared_Layout.cshtml para abrirlo en el editor de Visual Studio.

  9. Reemplace todas las repeticiones de Mi aplicación ASP.NET por Productos de Northwind Traders.

  10. Quite los vínculos Página principal, Acerca de y Contacto. Elimine el código resaltado:

    Screenshot of the code with three lines of H T M L Action Link code highlighted.

  11. Finalmente, modifique la página de envío para incluir información sobre la cola. En el Explorador de soluciones, haga doble clic en el archivo Views\Home\Submit.cshtml para abrirlo en el editor de Visual Studio. Agregue la línea siguiente después de <h2>Submit</h2>. Por ahora, ViewBag.MessageCount está vacío. Lo rellenará más adelante.

    <p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
    
  12. Acaba de implementar su interfaz de usuario. Puede presionar F5 para ejecutar la aplicación y confirmar que tiene el aspecto previsto.

    Screenshot of the application's Submit page.

Especificación del código para enviar elementos a una cola de Service Bus

Ahora, agregue el código para enviar elementos a una cola. En primer lugar, va a crear una clase que contiene la información de conexión a la cola de Service Bus. A continuación, inicialice la conexión en Global.aspx.cs. Finalmente, actualice el código de envío que creó antes en HomeController.cs para enviar realmente los elementos a una cola de Service Bus.

  1. En el Explorador de soluciones, haga clic con el botón derecho en FrontendWebRole (haga clic con el botón derecho en el proyecto, no en el rol). Seleccione Agregar y después Clase.

  2. Asigne a la clase el nombre QueueConnector.cs. Seleccione Agregar para crear la clase.

  3. Ahora va a agregar código que encapsula la información de conexión e inicializará la conexión a una cola de Service Bus. Reemplace todo el contenido de QueueConnector.cs por el código siguiente y escriba valores para your Service Bus namespace (el nombre del espacio de nombres) y yourKey, la clave principal que obtuvo antes en Azure Portal.

     using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Web;
     using System.Threading.Tasks;
     using Azure.Messaging.ServiceBus;
     using Azure.Messaging.ServiceBus.Administration;
    
    namespace FrontendWebRole
    {
         public static class QueueConnector
         {
             // object to send messages to a Service Bus queue
             internal static ServiceBusSender SBSender;
    
             // object to create a queue and get runtime properties (like message count) of queue
             internal static ServiceBusAdministrationClient SBAdminClient;
    
             // Fully qualified Service Bus namespace
             private const string FullyQualifiedNamespace = "<SERVICE BUS NAMESPACE NAME>.servicebus.windows.net";
    
             // The name of your queue.
             internal const string QueueName = "OrdersQueue";
    
             public static async Task Initialize()
             {
                 // Create a Service Bus client that you can use to send or receive messages
                 ServiceBusClient SBClient = new ServiceBusClient(FullyQualifiedNamespace, new DefaultAzureCredential());
    
                 // Create a Service Bus admin client to create queue if it doesn't exist or to get message count
                 SBAdminClient = new ServiceBusAdministrationClient(FullyQualifiedNamespace, new DefaultAzureCredential());
    
                 // create the OrdersQueue if it doesn't exist already
                 if (!(await SBAdminClient.QueueExistsAsync(QueueName)))
                 {
                     await SBAdminClient.CreateQueueAsync(QueueName);
                 }
    
                 // create a sender for the queue 
                 SBSender = SBClient.CreateSender(QueueName);    
             }
         }    
    }
    
  4. Ahora, asegúrese de que se llama al método Initialize. En el Explorador de soluciones, haga doble clic en Global.asax\Global.asax.cs.

  5. Agregue la siguiente línea de código al final del método Application_Start.

     FrontendWebRole.QueueConnector.Initialize().Wait();
    
  6. Por último, actualice el código web que creó anteriormente para enviar elementos a la cola. En el Explorador de soluciones, haga doble clic en Controllers\HomeController.cs.

  7. Actualice el método Submit() (la sobrecarga que no acepta parámetros) como sigue para obtener el número de mensajes de la cola.

         public ActionResult Submit()
         {
             QueueRuntimeProperties properties = QueueConnector.adminClient.GetQueueRuntimePropertiesAsync(QueueConnector.queueName).Result;
             ViewBag.MessageCount = properties.ActiveMessageCount;
    
             return View();
         }
    
  8. Actualice el método Submit(OnlineOrder order) (la sobrecarga que no acepta parámetros) como sigue para enviar información de pedidos a la cola.

         public ActionResult Submit(OnlineOrder order)
         {
             if (ModelState.IsValid)
             {
                 // create a message 
                 var message = new ServiceBusMessage(new BinaryData(order));
    
                 // send the message to the queue
                 QueueConnector.sbSender.SendMessageAsync(message);
    
                 return RedirectToAction("Submit");
             }
             else
             {
                 return View(order);
             }
         }
    
  9. Ahora puede volver a ejecutar la aplicación. Cada vez que envía un pedido, el contador de mensajes aumenta.

    Screenshot of the application's Submit page with the message count incremented to 1.

Creación del rol de trabajo

Ahora creará el rol de trabajo que procesa los envíos de pedidos. Este ejemplo utiliza la plantilla de proyecto de Visual Studio de rol de trabajo con cola de Service Bus. Ya ha obtenido las credenciales necesarias del portal.

  1. Asegúrese de que se ha conectado Visual Studio a su cuenta de Azure.

  2. En Visual Studio, en el Explorador de soluciones, haga clic con el botón derecho en la carpeta Roles en el proyecto MultiTierApp.

  3. Seleccione Agregar y después Nuevo proyecto de rol de trabajo. Aparecerá el cuadro de diálogo Agregar nuevo proyecto de rol.

    Screenshot of the Solution Explorer pane with the New Worker Role Project option and Add option highlighted.

  4. En el cuadro de diálogo Agregar nuevo proyecto de rol, seleccione Rol de trabajo. No seleccione Rol de trabajo con cola de Service Bus, ya que genera código que usa el SDK de Service Bus heredado.

    Screenshot of the Ad New Role Project dialog box with the Worker Role with Service Bus Queue option highlighted and outlined in red.

  5. En el cuadro Nombre, asigne al proyecto el nombre OrderProcessingRole. A continuación, seleccione Agregar.

  6. En el Explorador de soluciones, haga clic con el botón derecho en el proyecto OrderProcessingRole y seleccione Administrar paquetes NuGet.

  7. Seleccione la pestaña Examinar y, después, busque Azure.Messaging.ServiceBus. Seleccione el paquete Azure.Messaging.ServiceBus, seleccione Instalar y acepte las condiciones de uso.

    Screenshot of the Manage NuGet Packages dialog box with the Azure.Messaging.ServiceBus highlighted and the Install option outlined in red.

  8. Siga los mismos pasos para agregar el paquete NuGet Azure.Identity al proyecto.

  9. Cree una clase OnlineOrder para representar los pedidos cuando los procese desde la cola. Puede reutilizar una clase que ya ha creado. En el Explorador de soluciones, haga clic con el botón derecho en la clase OrderProcessingRole (haga clic con el botón derecho en el icono de clase, no en el rol). Seleccione Agregar y después Elemento existente.

  10. Busque FrontendWebRole\Models en la subcarpeta y haga doble clic en OnlineOrder.cs para agregarlo a este proyecto.

  11. Agregue la siguiente instrucción using al archivo WorkerRole.cs del proyecto OrderProcessingRole.

    using FrontendWebRole.Models;
    using Azure.Messaging.ServiceBus;
    using Azure.Messaging.ServiceBus.Administration; 
    
  12. En WorkerRole.cs, agregue las siguientes propiedades.

    Importante

    Use la cadena de conexión para el espacio de nombres que anotó como parte de los requisitos previos.

        // Fully qualified Service Bus namespace
        private const string FullyQualifiedNamespace = "<SERVICE BUS NAMESPACE NAME>.servicebus.windows.net";
    
        // The name of your queue.
        private const string QueueName = "OrdersQueue";
    
        // Service Bus Receiver object to receive messages message the specific queue
        private ServiceBusReceiver SBReceiver;
    
    
  13. Actualice el método OnStart para crear un objeto ServiceBusClient y, a continuación, un objeto ServiceBusReceiver para recibir mensajes de OrdersQueue.

        public override bool OnStart()
        {
            // Create a Service Bus client that you can use to send or receive messages
            ServiceBusClient SBClient = new ServiceBusClient(FullyQualifiedNamespace, new DefaultAzureCredential());
    
            CreateQueue(QueueName).Wait();
    
            // create a receiver that we can use to receive the message
            SBReceiver = SBClient.CreateReceiver(QueueName);
    
            return base.OnStart();
        }
        private async Task CreateQueue(string queueName)
        {
            // Create a Service Bus admin client to create queue if it doesn't exist or to get message count
            ServiceBusAdministrationClient SBAdminClient = new ServiceBusAdministrationClient(FullyQualifiedNamespace, new DefaultAzureCredential());
    
            // create the OrdersQueue if it doesn't exist already
            if (!(await SBAdminClient.QueueExistsAsync(queueName)))
            {
                await SBAdminClient.CreateQueueAsync(queueName);
            }
        }
    
  14. Actualice el método RunAsync para incluir el código para recibir mensajes.

        private async Task RunAsync(CancellationToken cancellationToken)
        {
            // TODO: Replace the following with your own logic.
            while (!cancellationToken.IsCancellationRequested)
            {
                // receive message from the queue
                ServiceBusReceivedMessage receivedMessage = await SBReceiver.ReceiveMessageAsync();
    
                if (receivedMessage != null)
                {
                    Trace.WriteLine("Processing", receivedMessage.SequenceNumber.ToString());
    
                    // view the message as an OnlineOrder
                    OnlineOrder order = receivedMessage.Body.ToObjectFromJson<OnlineOrder>();
                    Trace.WriteLine(order.Customer + ": " + order.Product, "ProcessingMessage");
    
                    // complete message so that it's removed from the queue
                    await SBReceiver.CompleteMessageAsync(receivedMessage);
                }
            }
        }
    
  15. Ha completado la aplicación. Puede probar la aplicación completa haciendo clic con el botón derecho en el proyecto MultiTierApp en el Explorador de soluciones, seleccionando Establecer como proyecto de inicio y, a continuación, presionando F5. El contador de mensajes no aumenta, ya que el rol de trabajo procesa los elementos de la cola y los marca como finalizados. Puede ver el resultado de seguimiento de su rol de trabajo viendo la interfaz de usuario del emulador de Azure Compute. Para ello, haga clic con el botón derecho en el icono del emulador del área de notificación de la barra de tareas y seleccione Mostrar interfaz de usuario del emulador de proceso.

    Screenshot of what appears when you select the emulator icon. Show Compute Emulator UI is in the list of options.

    Screenshot of the Microsoft Azure Compute Emulator (Express) dialog box.

Pasos siguientes

Para obtener más información sobre Service Bus, consulte los siguientes recursos: