Aplicativo multicamadas .NET usando filas do Barramento de Serviço do Azure

O desenvolvimento para o Microsoft Azure é fácil usando o Visual Studio e o SDK do Azure gratuito para o .NET. Este tutorial orienta você nas etapas para criar um aplicativo que usa vários recursos do Azure em execução no seu ambiente local.

Você aprenderá o seguinte:

  • Habilitar o computador para o desenvolvimento do Azure com um único download e instalar.
  • Usar o Visual Studio para desenvolver para o Azure.
  • Criar um aplicativo multicamadas no Azure usando funções web e de trabalho.
  • Como comunicar-se entre camadas usando filas do Barramento de Serviço.

Observação

Para concluir este tutorial, você precisa de uma conta do Azure. Você pode ativar os benefícios de assinante do MSDN ou se inscrever para fazer uma conta gratuita.

Neste tutorial você compilará e executará o aplicativo de multicamadas em um serviço de nuvem do Azure. O front-end é uma função Web MVC do ASP.NET e o back-end é uma função de trabalho que usa uma fila do Barramento de Serviço. Você pode criar o mesmo aplicativo multicamadas com o front-end que o de um projeto Web implantado em um site do Azure, em vez de em um serviço de nuvem. Você também pode experimentar o tutorial Aplicativo .NET híbrido local/na nuvem.

A captura de tela a seguir mostra o aplicativo concluído.

Application's Submit page

Visão geral de cenário: comunicação interfunções

Para enviar um pedido para processamento, o componente de UI de front-end, executando a função web, é necessário interagir com a lógica de camada intermediária em execução na função de trabalho. Este exemplo usa a mensagem do Barramento de Serviço para a comunicação entre as camadas.

Usar a mensagem do Barramento de Serviço entre a Web e as camadas intermediárias separa os dois componentes. Ao contrário das mensagens diretas (ou seja, TCP ou HTTP), a camada da Web não se conecta com a camada intermediária diretamente. Em vez disso, ela envia unidades de trabalho, como mensagens, para o Barramento de Serviço, que as mantém confiáveis até a camada intermediária estar pronta para as consumir e processar.

O Barramento de Serviço fornece duas entidades para dar suporte ao sistema de mensagens agenciado: filas e tópicos. Com filas, cada mensagem enviada para a fila é consumida por um único destinatário. Os tópicos dão suporte ao padrão de publicação/assinatura em que cada mensagem publicada é disponibilizada para uma assinatura registrada com o tópico. Cada assinatura mantém logicamente sua própria fila de mensagens. As assinaturas também podem ser configuradas com as regras de filtro que restringem o conjunto de mensagens passado para a fila de assinatura para aquelas que correspondem ao filtro. O exemplo a seguir usa filas do barramento de serviço.

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

Esse mecanismo de comunicação oferece diversas vantagens sobre mensagens diretas:

  • Desacoplamento temporal. Quando você usa o padrão de mensagens assíncronas, os produtores e consumidores não precisam estar online ao mesmo tempo. O ServiceBus armazena de forma confiável as mensagens até que a parte de consumo esteja prontapara recebê-las. Isso permite que os componentes do aplicativo distribuído sejam desconectados voluntariamente, por exemplo, para manutenção ou devido a uma falha de componente, sem afetar o sistema como um todo. Além disso, o aplicativo de consumo só precisa ser colocado online durante determinadas horas do dia.

  • Nivelamento de carga. Em muitos aplicativos, a carga do sistema varia ao longo do tempo enquanto o tempo de processamento necessário para cada unidade de trabalho for normalmente constante. Intermediar produtores de mensagem e consumidorescom uma fila significa que o aplicativo de consumo (o função de trabalho) sóprecisa ser configurado para acomodar a carga média em vez de pico decarga. A profundidade da fila aumentará e diminuirá conforme a carga de entrada variar. Isso economiza dinheiro diretamente em termos da quantidade deinfraestrutura necessária para atender à carga do aplicativo.

  • Balanceamento de carga. Conforme a carga aumenta, mais processos de função de trabalho podem seradicionados à leitura da fila. Cada mensagem é processada por apenas umdos processos de trabalho. Além disso, esse balanceamento de carga com base em pull permite uma utilização ideal dos computadores de trabalho mesmo se eles forem diferentes em termos de capacidade de processamento, pois extrairão as mensagens na respectiva taxa máxima. Esse padrão é geralmente denominado de consumidor concorrente.

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

As seções a seguir discutem o código que implementa essa arquitetura.

Pré-requisitos

Neste tutorial, você usará a autenticação do Microsoft Entra para criar objetos ServiceBusClient e ServiceBusAdministrationClient. Você também usará o DefaultAzureCredential e, para usá-lo, você precisará executar as etapas a seguir para testar o aplicativo localmente em um ambiente de desenvolvimento.

  1. Registre um aplicativo no Microsoft Entra ID.
  2. Adicione o aplicativo à função Service Bus Data Owner.
  3. Defina as variáveis de ambiente AZURE-CLIENT-ID, AZURE-TENANT-ID e AZURE-CLIENT-SECRET. Para obter instruções, confira este artigo.

Para obter uma lista de funções internas do Barramento de Serviço, consulte Funções internas do Azure para o Barramento de Serviço.

Criar um namespace

A primeira etapa é criar um namespace e obter uma chave de SAS (Assinatura de Acesso Compartilhado) chave para esse namespace. Um namespace fornece um limite de aplicativo para cada aplicativo exposto por meio do Barramento de Serviço. A chave SAS é gerada pelo sistema quando um namespace de serviço é criado. A combinação do nome do namespace e a chave SAS fornece as credenciais para o Barramento de Serviço autenticar o acesso a um aplicativo.

Criar um namespace no Portal do Azure

Para começar a usar as entidades de mensagens do Barramento de Serviço no Azure, primeiro é necessário criar um namespace com um nome exclusivo no Azure. Um namespace fornece um contêiner de escopo para recursos do Barramento de Serviço (filas, tópicos, etc.) dentro de seu aplicativo.

Para criar um namespace:

  1. Entre no portal do Azure.

  2. Navegue até a página Todos os serviços.

  3. Na barra de navegação à esquerda, selecione Integração na lista de categorias. Passe o mouse sobre Barramento de Serviço e, em seguida, selecione o botão + no bloco do Barramento de Serviço.

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

  4. Na marca Informações Básicas da página Criar namespace, siga estas etapas:

    1. Em Assinatura, escolha uma assinatura do Azure na qual criar o namespace.

    2. Em Grupo de recursos, escolha um grupo de recursos existente no qual o namespace residirá ou então crie um novo.

    3. Insira um nome para o namespace. O nome do namespace deve estar de acordo com as convenções de nomenclatura abaixo:

      • O nome deve ser exclusivo em todo o Azure. O sistema imediatamente verifica para ver se o nome está disponível.
      • O nome deve ter no mínimo seis e no máximo 50 caracteres.
      • O campo pode conter apenas letras, números e hifens "-".
      • O nome precisa começar com uma letra e terminar com uma letra ou um número.
      • O nome não termina com “-sb“ nem “-mgmt“.
    4. Em Localização, escolha a região na qual o namespace deve ser hospedado.

    5. Selecione o Tipo de preço (Básico, Standard ou Premium) do namespace. Para esse início rápido, selecione Padrão.

      Importante

      Se você quiser usar tópicos e assinaturas, escolha Standard ou Premium. Não há suporte para os tópicos/assinaturas no tipo de preço básico.

      Se você selecionou o tipo de preço Premium, especifique o número de unidades do sistema de mensagens. A camada Premium fornece isolamento de recursos no nível de CPU e memória, de modo que cada carga de trabalho seja executada isoladamente. Esse contêiner de recursos é chamado de unidade do sistema de mensagens. Um namespace premium tem pelo menos uma unidade do sistema de mensagens. Você pode selecionar 1, 2, 4, 8 ou 16 unidades do sistema de mensagens para cada namespace Premium do Barramento de Serviço. Para saber mais, confira Sistema de Mensagens Premium do Barramento de Serviço.

    6. Selecione Revisar + criar na parte inferior da página.

      Image showing the Create a namespace page

    7. Na páginaRevisar + criar,revise as configurações e selecioneCriar.

  5. Depois que a implantação do recurso for bem-sucedida, selecione Ir para o recurso na página de implantação.

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

  6. Você verá a home page do namespace do barramento de serviço.

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

Obter a cadeia de conexão para o namespace (portal do Azure)

Criar um namespace gera automaticamente uma política inicial de SAS (Assinatura de Acesso Compartilhado) com chaves primárias e secundárias e cadeias de conexão primárias e secundárias que concedem controle total sobre todos os aspectos do namespace. Consulte Autenticação e autorização do Barramento de Serviço para obter informações sobre como criar regras com direitos mais restritos para remetentes e destinatários regulares.

Um cliente pode usar a cadeia de conexão para se conectar ao namespace do Barramento de Serviço. Para copiar a cadeia de conexão primária para seu namespace, siga estas etapas:

  1. Na página Namespace do Barramento de Serviço, selecione Políticas de acesso compartilhado no menu à esquerda.

  2. Na página Políticas de acesso compartilhado, selecione RootManageSharedAccessKey.

  3. Na janela Política: RootManageSharedAccessKey, selecione o botão Copiar próximo à Cadeia de Conexão Primária para copiar a cadeia de conexão na área de transferência para uso posterior. Cole esse valor no Bloco de notas ou em outro local temporário.

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

    Você pode usar essa página para copiar a chave primária, a chave secundária, a cadeia de conexão primária e a cadeia de conexão secundária.

Criar uma função Web

Nesta seção, você compila o front-end de seu aplicativo. Primeiro, você cria as páginas que seu aplicativo exibe. Depois, adiciona o código que envia os itens para uma fila do Barramento de Serviço e exibe as informações de status sobre a fila.

Criar o projeto

  1. Usando privilégios de administrador, inicie o Visual Studio: clique com o botão direito no ícone do programa Visual Studio e selecione Executar como administrador. O emulador de computação do Azure, discutido mais adiante neste artigo, exige iniciar o Visual Studio com privilégios de administrador.

    No Visual Studio, no menu Arquivo, selecione Novo e selecione Projeto.

  2. Na página Modelos, siga estas etapas:

    1. Selecione C# como linguagem de programação.

    2. Selecione Nuvem como tipo de projeto.

    3. Selecione Serviço de Nuvem do Azure.

    4. Selecione Avançar.

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

  3. Nomeie o projeto MultiTierApp, selecione o local para o projeto e, em seguida, selecione Criar.

    Specify project name.

  4. Na página Funções, clique duas vezes em Função Web ASP.NET e selecione OK.

    Select Web Role

  5. Posicione o cursor sobre WebRole1 em Solução do Serviço de Nuvem do Azure, escolha o ícone de lápis e renomeie a função Web para FrontendWebRole. Depois, selecione OK. (Certifique-se de inserir "Frontend" com "e" minúsculo, não "FrontEnd".)

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

  6. Na caixa de diálogo Criar Aplicativo Web ASP.NET, selecione MVC e escolha Criar.

    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. No Gerenciador de Soluções, no projeto FrontendWebRole, clique com botão direito do mouse em Referências e selecione Gerenciar Pacotes NuGet.

  8. Selecione a guia Procurar e então procure Azure.Messaging.ServiceBus. Selecione o pacote Azure.Messaging.ServiceBus, selecione Instalar e aceite os termos de uso.

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

    Os assemblies de cliente obrigatórios agora são referenciados e alguns arquivos de código novos foram adicionados.

  9. Siga as mesmas etapas para adicionar o pacote NuGet Azure.Identity ao projeto.

  10. No Gerenciador de Soluções, expanda FronendWebRole, clique com o botão direito do mouse em Modelos e selecione Adicionar e Classe. Na caixa Nome, digite o nome OnlineOrder.cs. Em seguida, selecioneAdicionar.

Escreva o código para a função Web

Nesta seção, você cria várias páginas que exibem seu aplicativo.

  1. No arquivo OnlineOrder.cs do Visual Studio, substitua a definição do namespace existente pelo seguinte código:

    namespace FrontendWebRole.Models
    {
        public class OnlineOrder
        {
            public string Customer { get; set; }
            public string Product { get; set; }
        }
    }
    
  2. No Gerenciador de Soluções, clique duas vezes em Controllers\HomeController.cs. Adicione as seguintes instruções using na parte superior do arquivo para incluir os namespaces do modelo que você acabou de criar, bem como o Barramento de Serviço.

     using FrontendWebRole.Models;
     using Azure.Messaging.ServiceBus;    
    
  3. Também no arquivo HomeController.cs do Visual Studio, substitua a definição do namespace existente pelo código a seguir. Esse código contém métodos para processar o envio de itens para a fila.

    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. No menu Compilar, selecione Compilar Solução para testar a precisão do seu trabalho até o momento.

  5. Agora, crie a exibição do método Submit() criado anteriormente. Clique com o botão direito do mouse no método Submit() (a sobrecarga de Submit() que não usa nenhum parâmetro) no arquivo HomeController.cs e, em seguida, escolha Adicionar Exibição.

  6. Na caixa de diálogo Adicionar Novo Item com Scaffolding, selecione Adicionar.

  7. Na caixa de diálogo Adicionar Exibição, siga estas etapas:

    1. Na lista Modelo, escolha Criar.

    2. Na lista Classe do modelo, selecione a classe OnlineOrder.

    3. Selecione Adicionar.

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

  8. Agora, você alterará o nome exibido de seu aplicativo. No Gerenciador de Soluções, clique duas vezes no arquivo Views\Shared\_Layout.cshtml para abrir no editor do Visual Studio.

  9. Substitua todas as ocorrências de Meu Aplicativo ASP.NET para Produtos da Northwind Traders.

  10. Remova os links Página Inicial, Sobre e Contato. Exclua o código destacado:

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

  11. Por fim, modifique a página de envio para incluir algumas informações sobre a fila. No Gerenciador de Soluções, clique duas vezes no arquivo Views\Home\Submit.cshtml para abri-lo no editor do Visual Studio. Adicione a seguinte linha após <h2>Submit</h2>. Por enquanto, ViewBag.MessageCount está vazio. Você vai preenchê-lo mais tarde.

    <p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
    
  12. Você agora implementou a interface do usuário. Você pode pressionar F5 para executar o aplicativo e confirmar que parece conforme o esperado.

    Screenshot of the application's Submit page.

Escreva o código para enviar itens para uma fila do Brramento de Serviço

Agora, adicione o código para enviar itens para uma fila. Primeiro, você cria uma classe que contém as informações de conexão de fila do Barramento de Serviço. Em seguida, você inicializa a conexão do Global.aspx.cs. Por fim, você atualiza o código de envio criado anteriormente em HomeController.cs para efetivamente enviar itens para uma fila do Barramento de Serviço.

  1. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto FrontendWebRole (clique com o botão direito no projeto, e não na função). Selecione Adicionar e depois Classe.

  2. Nomeie a classe QueueConnector.cs. Selecione Adicionar para criar a classe.

  3. Agora, você adiciona o código que encapsula as informações da conexão e inicializa a conexão em uma fila do Barramento de Serviço. Substitua todo o conteúdo de QueueConnector.cs pelo código a seguir e insira valores para your Service Bus namespace (nome do namespace) e yourKey, que é a chave primária obtida anteriormente no portal do Azure.

     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. Agora, garanta que o método Initialize seja chamado. No Gerenciador de Soluções, clique duas vezes em Global.asax\Global.asax.cs.

  5. Adicione a linha de código a seguir ao fim do método Application_Start.

     FrontendWebRole.QueueConnector.Initialize().Wait();
    
  6. Por fim, atualize o código da Web criado anteriormente, para enviar itens para a fila. No Gerenciador de Soluções, clique duas vezes em Controllers\HomeController.cs.

  7. Atualize o método Submit() (a sobrecarga sem parâmetros) da seguinte maneira para obter a contagem de mensagens da fila.

         public ActionResult Submit()
         {
             QueueRuntimeProperties properties = QueueConnector.adminClient.GetQueueRuntimePropertiesAsync(QueueConnector.queueName).Result;
             ViewBag.MessageCount = properties.ActiveMessageCount;
    
             return View();
         }
    
  8. Atualize o método Submit(OnlineOrder order) (a sobrecarga com um parâmetro) da seguinte maneira para enviar as informações do pedido para a fila.

         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. Agora você pode executar o aplicativo novamente. Cada vez que você enviar umpedido, o número de mensagens aumenta.

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

Criar a função de trabalho

Agora você criará a função de trabalho que processa o envio de pedidos. Este exemplo usa o modelo de projeto do Visual Studio Função de Trabalho com Fila do Barramento de Serviço. Você já obteve as credenciais necessárias no portal.

  1. Certifique-se de ter conectado o Visual Studio à sua conta do Azure.

  2. No Visual Studio, no Gerenciador de Soluções, clique com o botão direito na pasta Funções no projeto AppVáriasCamadas.

  3. Escolha Adicionar e depois Novo Projeto de Função de Trabalho. A caixa de diálogo Adicionar Novo Projeto da Função é exibida.

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

  4. Na caixa de diálogo Adicionar Novo Projeto da Função, selecione Função de Trabalho. Não selecione Função de Trabalho com Fila do Barramento de Serviço, pois ela gera um código que usa o SDK do Barramento de Serviço herdado.

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

  5. Na caixa Nome, insira OrderProcessingRole. Em seguida, selecioneAdicionar.

  6. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto OrderProcessingRole e selecione Gerenciar Pacotes NuGet.

  7. Selecione a guia Procurar e então procure Azure.Messaging.ServiceBus. Selecione o pacote Azure.Messaging.ServiceBus, selecione Instalar e aceite os termos 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 as mesmas etapas para adicionar o pacote NuGet Azure.Identity ao projeto.

  9. Crie uma classe OnlineOrder para representar os pedidos conforme você os processa na fila. Você pode reutilizar uma classe já criada. No Gerenciador de Soluções, clique com o botão direito na classe OrderProcessingRole (clique com o botão direito no ícone da classe, não na função). Selecione Adicionar e depois Item Existente.

  10. Navegue até a subpasta para FrontendWebRole\Models e clique duas vezes em OnlineOrder.cs para adicioná-la a esse projeto.

  11. Adicione a instrução using a seguir ao arquivo WorkerRole.cs no projeto OrderProcessingRole.

    using FrontendWebRole.Models;
    using Azure.Messaging.ServiceBus;
    using Azure.Messaging.ServiceBus.Administration; 
    
  12. No WorkerRole.cs, adicione as propriedades a seguir.

    Importante

    Use a cadeia de conexão para o namespace que você anotou como parte dos pré-requisitos.

        // 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. Atualize o método OnStart para criar um objeto ServiceBusClient e, em seguida, um objeto ServiceBusReceiver para receber mensagens do 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. Atualize o método RunAsync para incluir o código para receber mensagens.

        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. Você concluiu o aplicativo. Você pode testar o aplicativo completo clicando com o botão direito do mouse no projeto AppVáriasCamadas no Gerenciador de Soluções, selecionando Definir como Projeto de Inicialização e pressionando F5. O número de mensagens não é incrementado, porque a função de trabalho processa itens da fila e os marca como concluído. Você pode ver a saída do rastreamento da função de trabalho, exibindo a interface do usuário do emulador de computação do Azure. É possível fazer isso clicando com o botão direito do mouse no ícone do emulador na área de notificação da sua barra de tarefas e selecionando Mostrar Interface do Usuário do Emulador de Computação.

    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.

Próximas etapas

Para obter mais informações sobre o Barramento de Serviço, consulte os seguintes recursos: