Exercício: enviar e receber mensagens de uma fila do Barramento de Serviço usando o .NET.

30 minutos

Nesse exercício, você aprenderá a:

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

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Caso ainda não tenha uma, inscreva-se em uma avaliação gratuita em https://azure.com/free.
Visual Studio Code em uma das plataformas compatíveis.
A Extensão do C# para Visual Studio Code.
.NET 8 é a estrutura alvo para o exercício.

Nesta seção, você abrirá o terminal e criará algumas variáveis usadas durante o restante do exercício para facilitar um pouco a entrada de comando e a criação de nome de recurso exclusivo.

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 conter os recursos do Azure que você criará.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Crie um namespace de mensagens do Barramento de Serviço. 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 Barramento de Serviço

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 Barramento de Serviço

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

Criar um aplicativo de console para enviar mensagens para a fila

Abra um terminal local, crie e altere para um diretório chamado az204svcbus e execute o comando para iniciar o Visual Studio Code.
```
code .
```
Abra o terminal no Visual Studio Code selecionando Terminal > Novo Terminal na barra de menus e execute os comandos a seguir 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 instruções a seguir using na parte superior do arquivo, após a instrução atual using.
```
using Azure.Messaging.ServiceBus;
```

Adicione as variáveis a seguir ao código e defina a variável connectionString como a cadeia de conexão obtida anteriormente.

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

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

Adicione o código a seguir abaixo das variáveis que você acabou de adicionar. Confira os comentários sobre 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 comando dotnet build para garantir que não haja erros.
Execute o programa usando o comando dotnet run e aguarde a mensagem de confirmação a seguir. Depois, pressione qualquer tecla para encerrar o programa.
```
A batch of three messages has been published to the queue.
```

Analisar resultados

Entre no portal do Azure e navegue até o namespace do Barramento de Serviço.
Selecione Filas na seção Entidades do painel de navegação e selecione az204-queue na lista.
Selecione o Service Bus Explorer no painel de navegação Fila do Barramento de Serviço.
Selecione Espiar desde o início e as três mensagens que foram enviadas serão exibidas.

Atualizar o projeto para receber mensagens para a fila

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

Adicione o seguinte código ao final do código existente. Confira os comentários sobre 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 comando dotnet build para garantir que não haja erros.
Use o comando dotnet run para executar o aplicativo. Ele vai enviar mais três mensagens à fila e recuperar as seis mensagens. Pressione qualquer tecla para interromper o recebimento 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
```
Observação

Como o aplicativo enviou dois lotes de mensagens antes de recuperá-las, você verá dois lotes de três mensagens representados na saída.
Retorne ao portal e selecione Espiar desde o início novamente. Observe que nenhuma mensagem aparece na fila, pois todas foram recuperadas.

Limpar os recursos

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

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