Ejercicio: Envío y recepción de mensajes de una cola de Service Bus mediante .NET.

30 minutos

En este ejercicio aprenderá a hacer lo siguiente:

Crear un espacio de nombres (y una cola) de Service Bus con la CLI de Azure.
Crear una aplicación de consola de .NET Core para enviar y recibir mensajes de la cola.

Prerrequisitos

Una cuenta de Azure con una suscripción activa. Si aún no tiene una, puede solicitar una prueba gratuita en https://azure.com/free.
Visual Studio Code en una de las plataformas admitidas.
La extensión de C# para Visual Studio Code.
.NET 6 es el marco de destino para el ejercicio.

En esta sección, va a abrir el terminal y a crear algunas variables que se usarán durante el resto del ejercicio para facilitar la entrada del comando y la creación de un nombre de recurso único.

Inicie Azure Cloud Shell y seleccione Bash y el entorno.
Cree variables que se usen en los comandos de la CLI de Azure. Reemplace <myLocation> por una región cercana.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Creación de recursos de Azure

Cree un grupo de recursos para contener los recursos de Azure que va a crear.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Cree un espacio de nombres de mensajería de Service Bus. El comando siguiente crea un espacio de nombres con la variable que ha creado antes. La operación tarda unos minutos en completarse.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Creación de una cola de Service Bus

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

Recuperación de la cadena de conexión para el espacio de nombres de Service Bus

Abra Azure Portal y vaya al grupo de recursos az204-svcbus-rg.
Seleccione el recurso az204svcbus que ha creado.
Seleccione Directivas de acceso compartido en la sección Configuración y elija la directiva RootManageSharedAccessKey.
Copie la Cadena de conexión principal del cuadro de diálogo que se abre y guárdela en un archivo, o bien deje el portal abierto y copie la clave cuando la necesite.

Creación de una aplicación de consola para enviar mensajes a la cola

Abra un terminal local y cree un directorio denominado az204svcbus. Vaya a este directorio y ejecute el comando para iniciar Visual Studio Code.
```
code .
```
Abra el terminal en Visual Studio Code mediante la selección de Terminal > Nuevo terminal en la barra de menús y ejecute los comandos siguientes para crear la aplicación de consola y agregar el paquete Azure.Messaging.ServiceBus.
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
En Program.cs, agregue las siguientes instrucciones using a la parte superior del archivo después de la instrucción using actual.
```
using Azure.Messaging.ServiceBus;
```

Agregue las siguientes variables al código y establezca la variable connectionStringen la cadena de conexión que obtuvo anteriormente.

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

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

Agregue el siguiente código debajo de las variables que acaba de agregar. Vea los comentarios de código para obtener más detalles.

// 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();

Guarde el archivo y ejecute el comando dotnet build para asegurarse de que no hay errores.
Ejecute el programa con el comando dotnet run y espere el mensaje de confirmación siguiente. Presione cualquier tecla para salir del programa.
```
A batch of three messages has been published to the queue.
```

Revisión de los resultados

Inicie sesión en Azure Portal y vaya a su espacio de nombres de Service Bus. Seleccione Service Bus Explorer en el panel de navegación de la cola de Service Bus.
Seleccione Peek from start (Ver desde el inicio) y aparecerán los tres mensajes enviados.

Actualización del proyecto para recibir mensajes de la cola

En esta sección, va a actualizar el programa para recibir mensajes de la cola.

Agregue el siguiente código al final del código existente. Vea los comentarios de código para obtener más detalles.

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 el comando dotnet build para asegurarse de que no hay errores.
Use el comando dotnet run para ejecutar la aplicación. Envía tres mensajes más a la cola y, después, recupera los seis mensajes. Presione cualquier tecla para detener el receptor y la aplicación.
```
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

Dado que la aplicación envió dos lotes de mensajes antes de recuperarlos, debería ver dos lotes de tres mensajes representados en la salida.
Vuelva al portal y seleccione de nuevo Ver desde el inicio. Observe que no aparecen mensajes en la cola, ya que los hemos recuperado todos.

Limpieza de recursos

Cuando los recursos ya no sean necesarios, puede usar el comando az group delete de Azure Cloud Shell para quitar el grupo de recursos.

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

Continuar