Introdução aos tópicos e assinaturas do Barramento de Serviço do Azure (.NET)

• C#
• Java
• JavaScript
• Python

Este guia de início rápido mostra como enviar mensagens para um tópico do Service Bus e receber mensagens de uma assinatura desse tópico usando a biblioteca .NET Azure.Messaging.ServiceBus .

Neste guia de início rápido, você executará as seguintes etapas:

1. Criar um espaço de nomes do Service Bus com o Portal do Azure.
2. Criar um tópico do Service Bus com o portal do Azure.
3. Criar uma subscrição do Service Bus com o portal do Azure.
4. Escreva um aplicativo de console .NET para enviar um conjunto de mensagens para o tópico.
5. Escreva um aplicativo de console .NET para receber essas mensagens da assinatura.

Nota

Este início rápido fornece instruções passo a passo para implementar um cenário simples de enviar um lote de mensagens para um tópico do Service Bus e receber essas mensagens de uma assinatura do tópico. Para obter mais exemplos em outros cenários avançados, consulte Exemplos do Service Bus .NET no GitHub.

• Este início rápido mostra duas maneiras de se conectar ao Barramento de Serviço do Azure: cadeia de conexão e sem senha. A primeira opção mostra como usar uma cadeia de conexão para se conectar a um namespace do Service Bus. A segunda opção mostra como usar sua entidade de segurança no Microsoft Entra ID e o controle de acesso baseado em função (RBAC) para se conectar a um namespace do Service Bus. Você não precisa se preocupar em ter uma cadeia de conexão codificada em seu código ou em um arquivo de configuração ou em armazenamento seguro, como o Azure Key Vault. Se você for novo no Azure, talvez ache a opção de cadeia de conexão mais fácil de seguir. Recomendamos o uso da opção sem senha em aplicativos e ambientes de produção do mundo real. Para obter mais informações, consulte Autenticação e autorização.

Pré-requisitos

Se você é novo no serviço, consulte Visão geral do Service Bus antes de fazer este início rápido.

• Subscrição do Azure. Para usar os serviços do Azure, incluindo o Barramento de Serviço do Azure, você precisa de uma assinatura. Se não tiver uma conta existente do Azure, pode inscrever-se para uma avaliação gratuita.
• Visual Studio 2022. O aplicativo de exemplo faz uso de novos recursos que foram introduzidos no C# 10. Você ainda pode usar a biblioteca de cliente do Service Bus com versões anteriores do idioma C#, mas a sintaxe pode variar. Para usar a sintaxe mais recente, recomendamos que você instale o .NET 6.0 ou superior e defina a versão de idioma como latest. Se você estiver usando o Visual Studio, as versões anteriores ao Visual Studio 2022 não são compatíveis com as ferramentas necessárias para criar projetos C# 10.

Criar um espaço de nomes no portal do Azure

Para começar a utilizar as entidades de mensagens do Service Bus no Azure, tem de, primeiro, criar um espaço de nomes que seja exclusivo em todo o Azure. Um namespace fornece um contêiner de escopo para recursos do Service Bus (filas, tópicos, etc.) em seu aplicativo.

Para criar um espaço de nomes:

1. Inicie sessão 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 o Service Bus e selecione + o botão no bloco do Service Bus.

   

4. Na marca Basics da página Criar namespace, siga estas etapas:

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

   2. Para Grupo de recursos, escolha um grupo de recursos existente no qual o namespace viverá ou crie um novo.

   3. Insira um nome para o namespace. O nome do namespace deve aderir às seguintes convenções de nomenclatura:

      • O nome deve ser exclusivo no Azure. O sistema verifica imediatamente a disponibilidade do nome.
      • O comprimento do nome é de pelo menos 6 e no máximo 50 caracteres.
      • O nome pode conter apenas letras, números hífenes "-".
      • O nome deve começar com uma letra e terminar com uma letra ou número.
      • O nome não termina com "-sb" ou "-mgmt".

   4. Em Local, escolha a região na qual seu namespace deve ser hospedado.

   5. Em Nível de preço, selecione o nível de preço (Básico, Standard ou Premium) para o namespace. Para este 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 tópicos/assinaturas no nível de preço Básico.

      Se você selecionou o nível de preço Premium, especifique o número de unidades de mensagens. A camada premium fornece isolamento de recursos no nível de CPU e memória para que cada carga de trabalho seja executada isoladamente. Este contentor de recursos é designado por unidade de mensagens. Um namespace premium tem pelo menos uma unidade de mensagens. Você pode selecionar 1, 2, 4, 8 ou 16 unidades de mensagens para cada namespace Premium do Service Bus. Para obter mais informações, consulte Mensagens Premium do Service Bus.

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

      

   7. Na página Rever + criar, reveja as definições e selecione Criar.

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

   

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

   

Criar um tópico com o portal do Azure

1. Na página Namespace do Service Bus, selecione Tópicos no menu à esquerda.

2. Selecione + Tópico na barra de ferramentas.

3. Insira um nome para o tópico. Deixe as outras opções com os valores predefinidos.

4. Selecione Criar.

   

Criar uma subscrição para o tópico

1. Selecione o tópico que você criou na seção anterior.

   

2. Na página Tópico do Service Bus, selecione + Assinatura na barra de ferramentas.

   

3. Na página Criar subscrição, siga estes passos:

   1. Digite S1 para o nome da assinatura.

   2. Digite 3 para Contagem máxima de entregas.

   3. Em seguida, selecione Criar para criar a assinatura.

      

Autenticar o aplicativo no Azure

Este início rápido mostra duas maneiras de se conectar ao Barramento de Serviço do Azure: sem senha e cadeia de conexão.

A primeira opção mostra como usar sua entidade de segurança no Microsoft Entra ID e RBAC (controle de acesso baseado em função) para se conectar a um namespace do Service Bus. Você não precisa se preocupar em ter uma cadeia de conexão codificada em seu código ou em um arquivo de configuração ou em um armazenamento seguro como o Azure Key Vault.

A segunda opção mostra como usar uma cadeia de conexão para se conectar a um namespace do Service Bus. Se você for novo no Azure, poderá achar a opção de cadeia de conexão mais fácil de seguir. Recomendamos o uso da opção sem senha em aplicativos e ambientes de produção do mundo real. Para obter mais informações, consulte Autenticação e autorização. Você também pode ler mais sobre autenticação sem senha na página de visão geral.

Sem senha

Atribuir funções ao usuário do Microsoft Entra

Ao desenvolver localmente, verifique se a conta de usuário que se conecta ao Barramento de Serviço do Azure tem as permissões corretas. Você precisará da função Proprietário de Dados do Barramento de Serviço do Azure para enviar e receber mensagens. Para atribuir essa função a si mesmo, você precisará da função de Administrador de Acesso de Usuário ou de outra função que inclua a Microsoft.Authorization/roleAssignments/write ação. Você pode atribuir funções do RBAC do Azure a um usuário usando o portal do Azure, a CLI do Azure ou o Azure PowerShell. Saiba mais sobre os escopos disponíveis para atribuições de função na página de visão geral do escopo.

O exemplo a seguir atribui a Azure Service Bus Data Owner função à sua conta de usuário, que fornece acesso total aos recursos do Barramento de Serviço do Azure. Em um cenário real, siga o Princípio do Menor Privilégio para dar aos usuários apenas as permissões mínimas necessárias para um ambiente de produção mais seguro.

Funções internas do Azure para o Barramento de Serviço do Azure

Para o Barramento de Serviço do Azure, o gerenciamento de namespaces e todos os recursos relacionados por meio do portal do Azure e da API de gerenciamento de recursos do Azure já está protegido usando o modelo RBAC do Azure. O Azure fornece as seguintes funções internas do Azure para autorizar o acesso a um namespace do Service Bus:

• Proprietário de Dados do Barramento de Serviço do Azure: habilita o acesso a dados ao namespace do Barramento de Serviço e suas entidades (filas, tópicos, assinaturas e filtros). Um membro dessa função pode enviar e receber mensagens de filas ou tópicos/assinaturas.
• Remetente de Dados do Barramento de Serviço do Azure: use essa função para conceder acesso de envio ao namespace do Barramento de Serviço e suas entidades.
• Recetor de Dados do Barramento de Serviço do Azure: use essa função para conceder acesso de recebimento ao namespace do Barramento de Serviço e suas entidades.

Se você quiser criar uma função personalizada, consulte Direitos necessários para operações do Service Bus.

Adicionar usuário do Microsoft Entra à função de Proprietário do Barramento de Serviço do Azure

Adicione seu nome de usuário do Microsoft Entra à função Proprietário de Dados do Barramento de Serviço do Azure no nível do namespace do Barramento de Serviço. Ele permitirá que um aplicativo em execução no contexto da sua conta de usuário envie mensagens para uma fila ou um tópico e receba mensagens de uma fila ou da assinatura de um tópico.

Importante

Na maioria dos casos, levará um ou dois minutos para que a atribuição de função se propague no Azure. Em casos raros, pode demorar até oito minutos. Se você receber erros de autenticação quando executar o código pela primeira vez, aguarde alguns momentos e tente novamente.

1. Se você não tiver a página Namespace do Service Bus aberta no portal do Azure, localize seu namespace do Service Bus usando a barra de pesquisa principal ou a navegação à esquerda.

2. Na página de visão geral, selecione Controle de acesso (IAM) no menu à esquerda.

3. Na página Controle de acesso (IAM), selecione a guia Atribuições de função.

4. Selecione + Adicionar no menu superior e, em seguida, Adicionar atribuição de função no menu suspenso resultante.

   

5. Use a caixa de pesquisa para filtrar os resultados para a função desejada. Para este exemplo, procure Azure Service Bus Data Owner e selecione o resultado correspondente. Em seguida, escolha Avançar.

6. Em Atribuir acesso a, selecione Utilizador, grupo ou entidade de serviço e, em seguida, selecione + Selecionar membros.

7. Na caixa de diálogo, procure seu nome de usuário do Microsoft Entra (geralmente seu endereço de e-mail user@domain ) e escolha Selecionar na parte inferior da caixa de diálogo.

8. Selecione Rever + atribuir para ir para a página final e, em seguida , Rever + atribuir novamente para concluir o processo.

Cadeia de Ligação

Obter a cadeia de ligação

A criação de um novo namespace gera automaticamente uma política inicial de Assinatura de Acesso Compartilhado (SAS) com chaves primárias e secundárias e cadeias de conexão primárias e secundárias que concedem controle total sobre todos os aspetos do namespace. Consulte Autenticação e autorização do Service Bus 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 Service Bus. Para copiar a cadeia de conexão primária para seu namespace, execute estas etapas:

1. Na página Namespace do Service Bus, selecione Políticas de acesso compartilhado no menu à esquerda.

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

3. Na janela Policy: RootManageSharedAccessKey, selecione o botão de cópia ao lado de Cadeia de conexão primária, para copiar a cadeia de conexão para a área de transferência para uso posterior. Cole este valor no Bloco de Notas ou noutra localização temporária.

   

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

Iniciar o Visual Studio e entrar no Azure

Você pode autorizar o acesso ao namespace do barramento de serviço usando as seguintes etapas:

1. Inicie o Visual Studio. Se você vir a janela Introdução , selecione o link Continuar sem código no painel direito.

2. Selecione o botão Entrar no canto superior direito do Visual Studio.

   

3. Entre usando a conta do Microsoft Entra à qual você atribuiu uma função anteriormente.

   

Enviar mensagens para o tópico

Esta seção mostra como criar um aplicativo de console .NET para enviar mensagens para um tópico do Service Bus.

Nota

Este início rápido fornece instruções passo a passo para implementar um cenário simples de enviar um lote de mensagens para um tópico do Service Bus e receber essas mensagens de uma assinatura do tópico. Para obter mais exemplos em outros cenários avançados, consulte Exemplos do Service Bus .NET no GitHub.

Criar uma aplicação de consola

1. No Visual Studio, selecione o menu Arquivo ->Novo ->Projeto .
2. Na caixa de diálogo Criar um novo projeto, execute as seguintes etapas: Se não vir esta caixa de diálogo, selecione Ficheiro no menu, selecione Novo e, em seguida, selecione Projeto.

   1. Selecione C# para a linguagem de programação.

   2. Selecione Console para o tipo do aplicativo.

   3. Selecione Aplicativo de console na lista de resultados.

   4. Em seguida, selecione Seguinte.

      

3. Digite TopicSender para o nome do projeto, ServiceBusTopicQuickStart para o nome da solução e selecione Next.
4. Na página Informações adicionais, selecione Criar para criar a solução e o projeto.

Adicionar os pacotes NuGet ao projeto

Sem senha

1. Selecione Ferramentas>NuGet Package Manager Package Manager>Console no menu.

2. Execute o seguinte comando para instalar o pacote NuGet Azure.Messaging.ServiceBus.

   Install-Package Azure.Messaging.ServiceBus
   

3. Execute o seguinte comando para instalar o pacote NuGet Azure.Identity.

   Install-Package Azure.Identity
   

Cadeia de Ligação

1. Selecione Ferramentas>NuGet Package Manager Package Manager>Console no menu.

2. Execute o seguinte comando para instalar o pacote NuGet Azure.Messaging.ServiceBus:

   Install-Package Azure.Messaging.ServiceBus
   

Adicionar código para enviar mensagens ao tópico

1. Substitua o conteúdo do Program.cs pelo código a seguir. As etapas importantes são descritas nesta seção, com informações adicionais nos comentários do código.

   Sem senha

   1. Cria um objeto ServiceBusClient usando o DefaultAzureCredential objeto. DefaultAzureCredential descobre e usa automaticamente as credenciais de sua entrada no Visual Studio para autenticar no Barramento de Serviço do Azure.
   2. Invoca o método CreateSender no ServiceBusClient objeto para criar um objeto ServiceBusSender para o tópico específico do Service Bus.
   3. Cria um objeto ServiceBusMessageBatch usando o ServiceBusSender.CreateMessageBatchAsync.
   4. Adicione mensagens ao lote usando ServiceBusMessageBatch.TryAddMessage.
   5. Envia o lote de mensagens para o tópico do Service Bus usando o método ServiceBusSender.SendMessagesAsync .

   Importante

   Atualize os valores de espaço reservado (<NAMESPACE-NAME> e <TOPIC-NAME>) no trecho de código com nomes de seu namespace e tópico do Service Bus.

   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   using Azure.Identity;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the sender used to publish messages to the topic
   ServiceBusSender sender;
   
   // number of messages to be sent to the topic
   const int numOfMessages = 3;
   
   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   
   //TODO: Replace the "<NAMESPACE-NAME>" and "<TOPIC-NAME>" placeholders.
   client = new ServiceBusClient(
       "<NAMESPACE-NAME>.servicebus.windows.net",
       new DefaultAzureCredential());
   sender = client.CreateSender("<TOPIC-NAME>");
   
   // create a batch 
   using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
   
   for (int i = 1; i <= numOfMessages; i++)
   {
       // try adding a message to the batch
       if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
       {
           // if it is too large for the batch
           throw new Exception($"The message {i} is too large to fit in the batch.");
       }
   }
   
   try
   {
       // Use the producer client to send the batch of messages to the Service Bus topic
       await sender.SendMessagesAsync(messageBatch);
       Console.WriteLine($"A batch of {numOfMessages} messages has been published to the topic.");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await sender.DisposeAsync();
       await client.DisposeAsync();
   }
   
   Console.WriteLine("Press any key to end the application");
   Console.ReadKey();
   

   Cadeia de Ligação

   Importante

   Atualize os valores de espaço reservado (<NAMESPACE-CONNECTION-STRING> e <TOPIC-NAME>) no trecho de código com os valores reais que você anotou anteriormente.

   1. Cria um objeto ServiceBusClient usando a cadeia de conexão para o namespace.
   2. Invoca o método CreateSender no ServiceBusClient objeto para criar um objeto ServiceBusSender para o tópico específico do Service Bus.
   3. Cria um objeto ServiceBusMessageBatch usando o ServiceBusSender.CreateMessageBatchAsync.
   4. Adicione mensagens ao lote usando ServiceBusMessageBatch.TryAddMessage.
   5. Envia o lote de mensagens para o tópico do Service Bus usando o método ServiceBusSender.SendMessagesAsync .

   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the sender used to publish messages to the topic
   ServiceBusSender sender;
   
   // number of messages to be sent to the topic
   const int numOfMessages = 3;
   
   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //TODO: Replace the "<NAMESPACE-CONNECTION-STRING>" and "<TOPIC-NAME>" placeholders.
   client = new ServiceBusClient("<NAMESPACE-CONNECTION-STRING>");
   sender = client.CreateSender("<TOPIC-NAME>");
   
   // create a batch 
   using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
   
   for (int i = 1; i <= numOfMessages; i++)
   {
       // try adding a message to the batch
       if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
       {
           // if it is too large for the batch
           throw new Exception($"The message {i} is too large to fit in the batch.");
       }
   }
   
   try
   {
       // Use the producer client to send the batch of messages to the Service Bus topic
       await sender.SendMessagesAsync(messageBatch);
       Console.WriteLine($"A batch of {numOfMessages} messages has been published to the topic.");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await sender.DisposeAsync();
       await client.DisposeAsync();
   }
   
   Console.WriteLine("Press any key to end the application");
   Console.ReadKey();
   

2. Crie o projeto e certifique-se de que não há erros.

3. Execute o programa e aguarde a mensagem de confirmação.

   A batch of 3 messages has been published to the topic
   

   Importante

   Na maioria dos casos, levará um ou dois minutos para que a atribuição de função se propague no Azure. Em casos raros, pode demorar até oito minutos. Se você receber erros de autenticação quando executar o código pela primeira vez, aguarde alguns momentos e tente novamente.

4. No portal do Azure, siga estas etapas:

   1. Navegue até o namespace do Service Bus.

   2. Na página Visão geral, no painel inferior central, alterne para a guia Tópicos e selecione o tópico do Service Bus. No exemplo a seguir, é mytopic.

      

   3. Na página Tópico do Service Bus, no gráfico Mensagens na seção Métricas inferior, você pode ver que há três mensagens de entrada para o tópico. Se não vir o valor, aguarde alguns minutos e atualize a página para ver o gráfico atualizado.

      

   4. Selecione a assinatura no painel inferior. No exemplo a seguir, é S1. Na página Assinatura do Service Bus, você verá a contagem de mensagens ativas como 3. A subscrição recebeu as três mensagens que enviou para o tópico, mas nenhum destinatário as escolheu ainda.

      

Receber mensagens de uma subscrição

Nesta seção, você cria um aplicativo de console .NET que recebe mensagens da assinatura do tópico Service Bus.

Nota

Este início rápido fornece instruções passo a passo para implementar um cenário simples de enviar um lote de mensagens para um tópico do Service Bus e receber essas mensagens de uma assinatura do tópico. Para obter mais exemplos em outros cenários avançados, consulte Exemplos do Service Bus .NET no GitHub.

Criar um projeto para o recetor

1. Na janela Gerenciador de Soluções, clique com o botão direito do mouse na solução ServiceBusTopicQuickStart, aponte para Adicionar e selecione Novo Projeto.
2. Selecione Aplicativo de console e selecione Avançar.
3. Digite SubscriptionReceiver para o nome do projeto e selecione Next.
4. Na página Informações adicionais, selecione Criar.
5. Na janela Gerenciador de Soluções, clique com o botão direito do mouse em SubscriptionReceiver e selecione Definir como um Projeto de Inicialização.

Adicionar os pacotes NuGet ao projeto

Sem senha

1. Selecione Ferramentas>NuGet Package Manager Package Manager>Console no menu.

2. Selecione SubscriptionReceiver para a lista suspensa do projeto padrão.

3. Execute o seguinte comando para instalar o pacote NuGet Azure.Messaging.ServiceBus.

   Install-Package Azure.Messaging.ServiceBus
   

4. Execute o seguinte comando para instalar o pacote NuGet Azure.Identity.

   Install-Package Azure.Identity
   

Cadeia de Ligação

1. Selecione Ferramentas>NuGet Package Manager Package Manager>Console no menu.

2. Execute o seguinte comando para instalar o pacote NuGet Azure.Messaging.ServiceBus:

   Install-Package Azure.Messaging.ServiceBus
   

Adicionar código para receber mensagens da subscrição

Nesta seção, você adiciona código para recuperar mensagens da assinatura.

1. Substitua o conteúdo existente do Program.cs pelas seguintes propriedades e métodos:

   Sem senha

   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   using Azure.Identity;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the processor that reads and processes messages from the subscription
   ServiceBusProcessor processor;    
   
   // handle received messages
   async Task MessageHandler(ProcessMessageEventArgs args)
   {
       string body = args.Message.Body.ToString();
       Console.WriteLine($"Received: {body} from subscription.");
   
       // complete the message. messages is deleted from the subscription. 
       await args.CompleteMessageAsync(args.Message);
   }
   
   // handle any errors when receiving messages
   Task ErrorHandler(ProcessErrorEventArgs args)
   {
       Console.WriteLine(args.Exception.ToString());
       return Task.CompletedTask;
   }
   

   Cadeia de Ligação

   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the processor that reads and processes messages from the subscription
   ServiceBusProcessor processor;    
   
   // handle received messages
   async Task MessageHandler(ProcessMessageEventArgs args)
   {
       // TODO: Replace the <TOPIC-SUBSCRIPTION-NAME> placeholder
       string body = args.Message.Body.ToString();
       Console.WriteLine($"Received: {body} from subscription: <TOPIC-SUBSCRIPTION-NAME>");
   
       // complete the message. messages is deleted from the subscription. 
       await args.CompleteMessageAsync(args.Message);
   }
   
   // handle any errors when receiving messages
   Task ErrorHandler(ProcessErrorEventArgs args)
   {
       Console.WriteLine(args.Exception.ToString());
       return Task.CompletedTask;
   }
   

2. Anexe o seguinte código ao final de Program.cs.

   Sem senha

   • Cria um objeto ServiceBusClient usando o DefaultAzureCredential objeto. DefaultAzureCredential descobre e usa automaticamente as credenciais de sua entrada no Visual Studio para autenticar no Barramento de Serviço do Azure.
   • Invoca o método CreateProcessor no ServiceBusClient objeto para criar um objeto ServiceBusProcessor para o tópico especificado do Service Bus.
   • Especifica manipuladores para os eventos ProcessMessageAsync e ProcessErrorAsync do ServiceBusProcessor objeto.
   • Inicia o processamento de mensagens invocando o StartProcessingAsync no ServiceBusProcessor objeto.
   • Quando o usuário pressiona uma tecla para encerrar o processamento, invoca o StopProcessingAsync no ServiceBusProcessor objeto.

   Importante

   Atualize os valores de espaço reservado (<NAMESPACE-NAME>, <TOPIC-NAME>, <SUBSCRIPTION-NAME>) no trecho de código com nomes de seu namespace, tópico e assinatura do Service Bus.

   Para obter mais informações, consulte comentários de código.

   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Create the clients that we'll use for sending and processing messages.
   // TODO: Replace the <NAMESPACE-NAME> placeholder
   client = new ServiceBusClient(
       "<NAMESPACE-NAME>.servicebus.windows.net",
       new DefaultAzureCredential());
   
   // create a processor that we can use to process the messages
   // TODO: Replace the <TOPIC-NAME> and <SUBSCRIPTION-NAME> placeholders
   processor = client.CreateProcessor("<TOPIC-NAME>", "<SUBSCRIPTION-NAME>", new ServiceBusProcessorOptions());
   
   try
   {
       // add handler to process messages
       processor.ProcessMessageAsync += MessageHandler;
   
       // add handler to process any errors
       processor.ProcessErrorAsync += ErrorHandler;
   
       // start processing 
       await processor.StartProcessingAsync();
   
       Console.WriteLine("Wait for a minute and then press any key to end the processing");
       Console.ReadKey();
   
       // stop processing 
       Console.WriteLine("\nStopping the receiver...");
       await processor.StopProcessingAsync();
       Console.WriteLine("Stopped receiving messages");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await processor.DisposeAsync();
       await client.DisposeAsync();
   }
   

   Cadeia de Ligação

   Importante

   Atualize os valores de espaço reservado (<NAMESPACE-CONNECTION-STRING>, <TOPIC-NAME>, <SUBSCRIPTION-NAME>) no trecho de código com os valores reais que você anotou anteriormente.

   • Cria um objeto ServiceBusClient usando a cadeia de conexão para o namespace.
   • Invoca o método CreateProcessor no ServiceBusClient objeto para criar um objeto ServiceBusProcessor para o tópico especificado do Service Bus.
   • Especifica manipuladores para os eventos ProcessMessageAsync e ProcessErrorAsync do ServiceBusProcessor objeto.
   • Inicia o processamento de mensagens invocando o StartProcessingAsync no ServiceBusProcessor objeto.
   • Quando o usuário pressiona uma tecla para encerrar o processamento, invoca o StopProcessingAsync no ServiceBusProcessor objeto.

   Para obter mais informações, consulte comentários de código.

   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Create the clients that we'll use for sending and processing messages.
   // TODO: Replace the <NAMESPACE-CONNECTION-STRING> placeholder
   client = new ServiceBusClient("<NAMESPACE-CONNECTION-STRING>");
   
   // create a processor that we can use to process the messages
   // TODO: Replace the <TOPIC-NAME> and <SUBSCRIPTION-NAME> placeholders
   processor = client.CreateProcessor("<TOPIC-NAME>", "<SUBSCRIPTION-NAME>", new ServiceBusProcessorOptions());
   
   try
   {
       // add handler to process messages
       processor.ProcessMessageAsync += MessageHandler;
   
       // add handler to process any errors
       processor.ProcessErrorAsync += ErrorHandler;
   
       // start processing 
       await processor.StartProcessingAsync();
   
       Console.WriteLine("Wait for a minute and then press any key to end the processing");
       Console.ReadKey();
   
       // stop processing 
       Console.WriteLine("\nStopping the receiver...");
       await processor.StopProcessingAsync();
       Console.WriteLine("Stopped receiving messages");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await processor.DisposeAsync();
       await client.DisposeAsync();
   }
   

3. Veja como deve Program.cs ser:

   Sem senha

   using System;
   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   using Azure.Identity;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the processor that reads and processes messages from the subscription
   ServiceBusProcessor processor;
   
   // handle received messages
   async Task MessageHandler(ProcessMessageEventArgs args)
   {
       string body = args.Message.Body.ToString();
       Console.WriteLine($"Received: {body} from subscription.");
   
       // complete the message. messages is deleted from the subscription. 
       await args.CompleteMessageAsync(args.Message);
   }
   
   // handle any errors when receiving messages
   Task ErrorHandler(ProcessErrorEventArgs args)
   {
       Console.WriteLine(args.Exception.ToString());
       return Task.CompletedTask;
   }
   
   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Create the clients that we'll use for sending and processing messages.
   // TODO: Replace the <NAMESPACE-NAME> placeholder
   client = new ServiceBusClient(
       "<NAMESPACE-NAME>.servicebus.windows.net",
       new DefaultAzureCredential());
   
   // create a processor that we can use to process the messages
   // TODO: Replace the <TOPIC-NAME> and <SUBSCRIPTION-NAME> placeholders
   processor = client.CreateProcessor("<TOPIC-NAME>", "<SUBSCRIPTION-NAME>", new ServiceBusProcessorOptions());
   
   try
   {
       // add handler to process messages
       processor.ProcessMessageAsync += MessageHandler;
   
       // add handler to process any errors
       processor.ProcessErrorAsync += ErrorHandler;
   
       // start processing 
       await processor.StartProcessingAsync();
   
       Console.WriteLine("Wait for a minute and then press any key to end the processing");
       Console.ReadKey();
   
       // stop processing 
       Console.WriteLine("\nStopping the receiver...");
       await processor.StopProcessingAsync();
       Console.WriteLine("Stopped receiving messages");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await processor.DisposeAsync();
       await client.DisposeAsync();
   }
   

   Cadeia de Ligação

   using System;
   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   
   // the client that owns the connection and can be used to create senders and receivers
   ServiceBusClient client;
   
   // the processor that reads and processes messages from the subscription
   ServiceBusProcessor processor;
   
   // handle received messages
   async Task MessageHandler(ProcessMessageEventArgs args)
   {
       string body = args.Message.Body.ToString();
       Console.WriteLine($"Received: {body} from subscription.");
   
       // complete the message. messages is deleted from the subscription. 
       await args.CompleteMessageAsync(args.Message);
   }
   
   // handle any errors when receiving messages
   Task ErrorHandler(ProcessErrorEventArgs args)
   {
       Console.WriteLine(args.Exception.ToString());
       return Task.CompletedTask;
   }
   
   // The Service Bus client types are safe to cache and use as a singleton for the lifetime
   // of the application, which is best practice when messages are being published or read
   // regularly.
   //
   // Create the clients that we'll use for sending and processing messages.
   // TODO: Replace the <NAMESPACE-CONNECTION-STRING> placeholder
   client = new ServiceBusClient("<NAMESPACE-CONNECTION-STRING>");
   
   // create a processor that we can use to process the messages
   // TODO: Replace the <TOPIC-NAME> and <SUBSCRIPTION-NAME> placeholders
   processor = client.CreateProcessor("<TOPIC-NAME>", "<SUBSCRIPTION-NAME>", new ServiceBusProcessorOptions());
   
   try
   {
       // add handler to process messages
       processor.ProcessMessageAsync += MessageHandler;
   
       // add handler to process any errors
       processor.ProcessErrorAsync += ErrorHandler;
   
       // start processing 
       await processor.StartProcessingAsync();
   
       Console.WriteLine("Wait for a minute and then press any key to end the processing");
       Console.ReadKey();
   
       // stop processing 
       Console.WriteLine("\nStopping the receiver...");
       await processor.StopProcessingAsync();
       Console.WriteLine("Stopped receiving messages");
   }
   finally
   {
       // Calling DisposeAsync on client types is required to ensure that network
       // resources and other unmanaged objects are properly cleaned up.
       await processor.DisposeAsync();
       await client.DisposeAsync();
   }
   

4. Crie o projeto e certifique-se de que não há erros.

5. Execute o aplicativo recetor. Você deve ver as mensagens recebidas. Pressione qualquer tecla para parar o recetor e o aplicativo.

   Wait for a minute and then press any key to end the processing
   Received: Message 1 from subscription: S1
   Received: Message 2 from subscription: S1
   Received: Message 3 from subscription: S1
   
   Stopping the receiver...
   Stopped receiving messages
   

6. Consulte novamente o portal.

   • Na página Tópico do Service Bus, no gráfico Mensagens, você verá três mensagens de entrada e três mensagens de saída. Se você não vir esses números, aguarde alguns minutos e atualize a página para ver o gráfico atualizado.

     

   • Na página Assinatura do Service Bus, você verá a contagem de mensagens Ativa como zero. É porque um destinatário recebeu mensagens desta subscrição e completou as mensagens.

     

Próximos passos

Consulte a seguinte documentação e exemplos:

• Biblioteca de cliente do Barramento de Serviço do Azure para .NET - Leiame
• Exemplos .NET para o Barramento de Serviço do Azure no GitHub
• Referência da API .NET