Exercício: Enviar e receber mensagens de uma fila do Service Bus usando o .NET.

30 minutos

Neste exercício você aprende a:

Crie um namespace e uma fila do Barramento de Serviço usando a CLI do Azure.
Crie um aplicativo de console .NET para enviar e receber mensagens da fila.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Se ainda não tiver uma, pode inscrever-se numa avaliação gratuita em https://azure.com/free.
Visual Studio Code numa das plataformas suportadas.
A extensão C# para o Visual Studio Code.
O .NET 8 é a estrutura de destino para o exercício.

Nesta seção, você abre seu terminal e cria algumas variáveis usadas durante o resto do exercício para tornar a entrada de comando e a criação de nome de recurso exclusivo um pouco mais fáceis.

Inicie o Azure Cloud Shell e selecione Bash e o ambiente.
Crie variáveis usadas nos comandos da CLI do Azure. Substitua <myLocation> por uma região perto de você.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Criar recursos do Azure

Crie um grupo de recursos para armazenar os recursos do Azure que você está criando.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Crie um namespace de mensagens do Service Bus. O comando a seguir cria um namespace usando a variável criada anteriormente. A operação leva alguns minutos para ser concluída.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Criar uma fila do Service Bus

az servicebus queue create --resource-group az204-svcbus-rg \
    --namespace-name $myNameSpaceName \
    --name az204-queue

Recuperar a cadeia de conexão para o namespace do Service Bus

Abra o portal do Azure e navegue até o grupo de recursos az204-svcbus-rg .
Selecione o recurso az204svcbus que você criou.
Selecione Políticas de acesso compartilhado na seção Configurações e, em seguida, selecione a política RootManageSharedAccessKey.
Copie a Cadeia de Conexão Primária da caixa de diálogo que a abre e salve-a em um arquivo, ou deixe o portal aberto e copie a chave quando necessário.

Criar aplicativo de console para enviar mensagens para a fila

Abra um terminal local e crie e altere para um diretório chamado az204svcbus e, em seguida, execute o comando para iniciar o Visual Studio Code.
```
code .
```
Abra o terminal no Visual Studio Code selecionando Terminal New Terminal na barra de menus e execute os seguintes comandos para criar o aplicativo de console e adicionar o pacote Azure.Messaging.ServiceBus.>
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
Em Program.cs, adicione as seguintes using instruções na parte superior do arquivo após a instrução atual using .
```
using Azure.Messaging.ServiceBus;
```

Adicione as seguintes variáveis ao código e defina a connectionString variável para a cadeia de conexão que você obteve anteriormente.

// connection string to your Service Bus namespace
string connectionString = "<CONNECTION STRING>";

// name of your Service Bus topic
string queueName = "az204-queue";

Adicione o seguinte código abaixo das variáveis que você acabou de adicionar. Consulte os comentários de código para obter detalhes.

// 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 queue
ServiceBusSender sender;

// Create the clients that we'll use for sending and processing messages.
client = new ServiceBusClient(connectionString);
sender = client.CreateSender(queueName);

// create a batch 
using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();

for (int i = 1; i <= 3; i++)
{
    // try adding a message to the batch
    if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
    {
        // if an exception occurs
        throw new Exception($"Exception {i} has occurred.");
    }
}

try
{
    // Use the producer client to send the batch of messages to the Service Bus queue
    await sender.SendMessagesAsync(messageBatch);
    Console.WriteLine($"A batch of three messages has been published to the queue.");
}
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("Follow the directions in the exercise to review the results in the Azure portal.");
Console.WriteLine("Press any key to continue");
Console.ReadKey();

Salve o arquivo e execute o dotnet build comando para garantir que não haja erros.
Execute o programa usando o dotnet run comando e aguarde a seguinte mensagem de confirmação. Em seguida, pressione qualquer tecla para sair do programa.
```
A batch of three messages has been published to the queue.
```

Rever resultados

Entre no portal do Azure e navegue até o namespace do Service Bus.
Selecione Filas na seção Entidades do painel de navegação e, em seguida, selecione a fila az204 na lista.
Selecione o Service Bus Explorer no painel de navegação Fila do Service Bus.
Selecione Espiar no início e as três mensagens enviadas serão exibidas.

Atualizar projeto para receber mensagens na fila

Nesta seção, você atualiza o programa para receber mensagens da fila.

Adicione o seguinte código no final do código existente. Consulte os comentários de código para obter detalhes.

ServiceBusProcessor processor;
client = new ServiceBusClient(connectionString);

// create a processor that we can use to process the messages
processor = client.CreateProcessor(queueName, 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();
}

// handle received messages
async Task MessageHandler(ProcessMessageEventArgs args)
{
    string body = args.Message.Body.ToString();
    Console.WriteLine($"Received: {body}");

    // complete the message. messages is deleted from the queue. 
    await args.CompleteMessageAsync(args.Message);
}

// handle any errors when receiving messages
Task ErrorHandler(ProcessErrorEventArgs args)
{
    Console.WriteLine(args.Exception.ToString());
    return Task.CompletedTask;
}

Use o dotnet build comando para garantir que não haja erros.
Use o dotnet run comando para executar o aplicativo. Ele envia mais três mensagens para a fila e, em seguida, recupera todas as seis mensagens. 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
Received: Message 2
Received: Message 3
Received: Message 1
Received: Message 2
Received: Message 3

Stopping the receiver...
Stopped receiving messages
```
Nota

Como o aplicativo enviou dois lotes de mensagens antes de recuperá-las, você deve ver dois lotes de três mensagens representadas na saída.
Volte ao portal e selecione Espreitar a partir do início novamente. Observe que nenhuma mensagem aparece na fila, pois recuperamos todas.

Clean up resources (Limpar recursos)

Quando os recursos não forem mais necessários, você poderá usar o az group delete comando no Azure Cloud Shell para remover o grupo de recursos.

az group delete --name az204-svcbus-rg --no-wait