Gyakorlat: Üzenet küldése és fogadása Service Bus-üzenetsorból a .NET használatával.

30 perc

Ebben a gyakorlatban megtanulhatja, hogyan:

Hozzon létre egy Service Bus-névteret és üzenetsort az Azure CLI használatával.
Hozzon létre egy .NET-konzolalkalmazást, amely üzeneteket küld és fogad az üzenetsorból.

Előfeltételek

Aktív előfizetéssel rendelkező Azure-fiók . Ha még nem rendelkezik előfizetéssel, regisztrálhat az ingyenes próbaverzióra a következő címen:https://azure.com/free.
Visual Studio Code az egyik támogatott platformon.
A Visual Studio Code C#-bővítménye.
A .NET 6 a gyakorlat cél keretrendszere.

Ebben a szakaszban megnyithatja a terminált, és a gyakorlat további részében használt változókat hozhat létre a parancsbejegyzés és az egyedi erőforrásnév létrehozása érdekében.

Indítsa el az Azure Cloud Shellt , és válassza a Basht és a környezetet.
Az Azure CLI-parancsokban használt változók létrehozása. Cserélje le <myLocation> az Önhöz közeli régióra.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Azure-erőforrások létrehozása

Hozzon létre egy erőforráscsoportot a létrehozott Azure-erőforrások tárolásához.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Hozzon létre egy Service Bus-üzenetkezelési névteret. Az alábbi parancs létrehoz egy névteret a korábban létrehozott változó használatával. A művelet végrehajtása néhány percet vesz igénybe.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Service Bus-üzenetsor létrehozása

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

A Service Bus-névtér kapcsolati sztring lekérése

Nyissa meg az Azure Portalt, és keresse meg az az204-svcbus-rg erőforráscsoportot.
Válassza ki a létrehozott az204svcbus erőforrást.
Válassza a megosztott hozzáférési szabályzatokat a Gépház szakaszban, majd válassza a RootManageSharedAccessKey szabályzatot.
Másolja az elsődleges Csatlakozás ion sztringet a megnyíló párbeszédpanelről, és mentse egy fájlba, vagy hagyja nyitva a portált, és szükség esetén másolja a kulcsot.

Konzolalkalmazás létrehozása üzenetek üzenetsorba küldéséhez

Nyisson meg egy helyi terminált, és hozzon létre egy az204svcbus nevű könyvtárat, majd futtassa a parancsot a Visual Studio Code elindításához.
```
code .
```
Nyissa meg a terminált a Visual Studio Code-ban a terminál új termináljának > kiválasztásával a menüsávon, és futtassa a következő parancsokat a konzolalkalmazás létrehozásához és az Azure.Messaging.ServiceBus-csomag hozzáadásához.
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
A Program.cs fájlban adja hozzá az alábbi using utasításokat a fájl tetején az aktuális using utasítás után.
```
using Azure.Messaging.ServiceBus;
```

Adja hozzá a következő változókat a kódhoz, és állítsa be a változót connectionString a korábban beszerzett kapcsolati sztring.

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

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

Adja hozzá az alábbi kódot az imént hozzáadott változók alá. Részletekért lásd a kód megjegyzéseit.

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

Mentse a fájlt, és futtassa a dotnet build parancsot, és győződjön meg arról, hogy nincsenek hibák.
Futtassa a programot a dotnet run paranccsal, és várja meg a következő megerősítési üzenetet. Ezután nyomja le bármelyik billentyűt a programból való kilépéshez.
```
A batch of three messages has been published to the queue.
```

Eredmények áttekintése

Jelentkezzen be az Azure Portalra, és keresse meg a Service Bus-névteret. Válassza ki a Service Bus Explorert a Service Bus-üzenetsor navigációs paneljén.
Válassza a Betekintő lehetőséget az elejétől kezdve , és megjelenik a három elküldött üzenet.

Projekt frissítése az üzenetsorba érkező üzenetek fogadásához

Ebben a szakaszban frissíti a programot, hogy üzeneteket fogadjon az üzenetsorból.

Adja hozzá a következő kódot a meglévő kód végén. Részletekért lásd a kód megjegyzéseit.

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;
}

dotnet build A parancs használatával győződjön meg arról, hogy nincsenek hibák.
dotnet run Az alkalmazás futtatásához használja a parancsot. További három üzenetet küld az üzenetsorba, majd lekéri mind a hat üzenetet. Nyomja le a kívánt billentyűt a fogadó és az alkalmazás leállításához.
```
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
```
Megjegyzés:

Mivel az alkalmazás két üzenetköteget küldött lekérés előtt, a kimenetben két három üzenetből álló kötegnek kell megjelennie.
Térjen vissza a portálra, és válassza újra a Betekintés lehetőséget. Figyelje meg, hogy nem jelennek meg üzenetek az üzenetsorban, mivel mindet lekértük.

Clean up resources

Ha az erőforrásokra már nincs szükség, az az group delete Azure Cloud Shell parancsával eltávolíthatja az erőforráscsoportot.

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

Folytatás