Gyakorlat – Üzenetek küldése és fogadása üzenetsor használatával

10 perc

Úgy döntött, hogy Service Bus-üzenetsort használ a mobilalkalmazás és az Azure-ban üzemeltetett webszolgáltatás közötti egyedi értékesítésekről szóló üzenetek kezeléséhez, amelyek egy Azure SQL Database-példányban tárolják az egyes értékesítések részleteit.

Az előző gyakorlatban implementálta a szükséges objektumokat az Azure-előfizetésében. Most meg szeretné írni a kódot, amely üzeneteket küld az üzenetsorba, és üzeneteket kér le.

Ebben a leckében két konzolalkalmazást fog létrehozni: az egyik alkalmazás egy Service Bus-üzenetsorba helyezi az üzeneteket, egy alkalmazás pedig egy Service Bus-üzenetsorból kéri le az üzeneteket. Az alkalmazások egy .NET Core-megoldás részei.

A kapcsolati sztring lekérése a Service Bus névterébe

Két információt kell konfigurálnia a két konzolalkalmazásban a Service Bus-névtér eléréséhez és a névtéren belüli üzenetsor használatához:

A névtér végpontja
Közös hozzáférési kulcs hitelesítéshez

Ezeket az értékeket a kapcsolati sztring érheti el.

A jobb oldali Azure Cloud Shellben futtassa a következő parancsot, és cserélje le <namespace-name> az előző gyakorlatban létrehozott Service Bus-névtérre.

az servicebus namespace authorization-rule keys list \
    --resource-group <rgn>[sandbox resource group name]</rgn> \
    --name RootManageSharedAccessKey \
    --query primaryConnectionString \
    --output tsv \
    --namespace-name <namespace-name>

A válasz utolsó sora a kapcsolati sztring, amely tartalmazza a névtér végpontját és a megosztott hozzáférési kulcsot. Ennek a következő példához kell hasonlítania:

Endpoint=sb://example.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=AbCdEfGhIjKlMnOpQrStUvWxYz==

Másolja a kapcsolati sztring a Cloud Shellből. A modul során többször is szüksége lesz erre a kapcsolati sztring, ezért érdemes lehet egy hasznos helyre menteni.

A kezdő szintű alkalmazás klónozása és megnyitása

Megjegyzés:

Az egyszerűség kedvéért az alábbi feladatok arra utasítják, hogy mindkét konzolalkalmazás Program.cs fájljában szigorúan kódozza a kapcsolati sztring. Éles alkalmazásokban konfigurációs fájlt vagy Azure Key Vaultot kell használnia a kapcsolati sztring tárolásához.

Futtassa a következő parancsot a Cloud Shellben a Git-projektmegoldás klónozásához:
```
cd ~
git clone https://github.com/MicrosoftDocs/mslearn-connect-services-together.git
```
Futtassa a következő parancsot a klónozott projekt kezdőmappájának megnyitásához és a Cloud Shell-szerkesztő megnyitásához:
```
cd ~/mslearn-connect-services-together/implement-message-workflows-with-service-bus/src/start
code .
```

Kód írása üzenet üzenetsorba való küldéséhez

A Cloud Shell-szerkesztőben nyissa meg a privatemessagesender/Program.cs fájlt, és keresse meg a következő kódsort:
```
const string ServiceBusConnectionString = "";
```
Illessze be a kapcsolati sztringet idézőjelek között.
Ha a salesmessagestől eltérő nevet használt az üzenetsornévhez, frissítse a kódban lévő tulajdonság értékétQueueName:
```
const string QueueName = "salesmessages";
```

Az értékesítésekről üzeneteket küldő összetevő befejezéséhez hozzá kell adnia egy operátort await , amely felfüggeszti az aszinkron metódus kiértékelését, amíg az aszinkron művelet befejeződik. Keresse meg a metódust SendSalesMessageAsync() . Ezen a metóduson belül keresse meg a kód alábbi sorát:

// Create a Service Bus client here

Cserélje le a kódsort a következő kódra:

// By leveraging "await using", the DisposeAsync method will be called automatically once the client variable goes out of scope. 
// In more realistic scenarios, you would want to store off a class reference to the client (rather than a local variable) so that it can be used throughout your program.

await using var client = new ServiceBusClient(ServiceBusConnectionString);

A metóduson SendSalesMessageAsync() belül keresse meg a következő kódsort:
```
// Create a sender here
```
Cserélje le a megjegyzést a következő kódra:
```
await using ServiceBusSender sender = client.CreateSender(QueueName);
```

A blokkon try...catch belül keresse meg a következő kódsort:

// Create and send a message here

Cserélje le a kódsort a következő kódsorra:

string messageBody = $"$10,000 order for bicycle parts from retailer Adventure Works.";
var message = new ServiceBusMessage(messageBody);

Szúrja be a következő kódot egy új sorba közvetlenül az imént hozzáadott szöveg alá, hogy megjelenjen az üzenet a konzolon:
```
Console.WriteLine($"Sending message: {messageBody}");
```
Szúrja be a következő kódot a következő sorba:
```
await sender.SendMessageAsync(message);
```

A feladó és az ügyfélobjektumok megsemmisítéséhez a fájl vége közelében keresse meg a következő megjegyzést:

// Close the connection to the sender here

Ezt a sort cserélje le a következő kódra:

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

Ellenőrizze, hogy a privatemessagesender/Program.cs végleges kódja hasonlít-e a következő példára:

using System;
using System.Text;
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;

namespace privatemessagesender
{
    class Program
    {
        const string ServiceBusConnectionString = "Endpoint=sb://example.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=AbCdEfGhIjKlMnOpQrStUvWxYz==";
        const string QueueName = "salesmessages";

        static void Main(string[] args)
        {
            Console.WriteLine("Sending a message to the Sales Messages queue...");
            SendSalesMessageAsync().GetAwaiter().GetResult();
            Console.WriteLine("Message was sent successfully.");
        }

        static async Task SendSalesMessageAsync()
        {
            await using var client = new ServiceBusClient(ServiceBusConnectionString);

            await using ServiceBusSender sender = client.CreateSender(QueueName);
            try
            {
                string messageBody = $"$10,000 order for bicycle parts from retailer Adventure Works.";
                var message = new ServiceBusMessage(messageBody);
                Console.WriteLine($"Sending message: {messageBody}");
                await sender.SendMessageAsync(message);
            }
            catch (Exception exception)
            {
                Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
            }
            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();
            }
        }
    }
}

A fájlt a Ctrl+S billentyűkombinációval mentse el, majd a Ctrl+Q billentyűkombinációval zárja be a szerkesztőt.

Üzenet küldése az üzenetsorba

A Cloud Shellben futtassa az alábbi parancsot egy értékesítésről szóló üzenet küldéséhez. Az első sor biztosítja, hogy a megfelelő elérési úton jár.
```
cd ~/mslearn-connect-services-together/implement-message-workflows-with-service-bus/src/start
dotnet run --project ./privatemessagesender
```
Megjegyzés:

Amikor először futtatja az alkalmazásokat ebben a gyakorlatban, lehetővé teszi dotnet a távoli forrásokból származó csomagok visszaállítását és az alkalmazások összeállítását.

A program futtatásakor a rendszer a konzolra nyomtatja az üzeneteket, amelyek jelzik, hogy az alkalmazás üzenetet küld:
```
Sending a message to the Sales Messages queue...
Sending message: $10,000 order for bicycle parts from retailer Adventure Works.
Message was sent successfully.
```
Ha az alkalmazás elkészült, futtassa a következő parancsot, és cserélje le <a névtér nevét> a Service Bus-névtér nevére. Ez a parancs az üzenetsorban lévő üzenetek számát adja vissza.
```
az servicebus queue show \
    --resource-group <rgn>[sandbox resource group name]</rgn> \
    --name salesmessages \
    --query messageCount \
    --namespace-name <namespace-name>
```
Futtassa újra a parancsot az dotnet run 1. lépésben, majd futtassa újra a servicebus queue show parancsot. A dotnet-alkalmazás minden futtatásakor egy új üzenet kerül az üzenetsorba. Az Azure-parancs minden futtatásakor megjelenik a messageCount növekedés.

Kód írása az üzenetek üzenetsorból történő fogadásához

Futtassa a következő parancsot a szerkesztő újbóli megnyitásához:
```
code .
```
A szerkesztőben nyissa meg a privatemessagereceiver/Program.cs fájlt, és keresse meg a következő kódsort:
```
const string ServiceBusConnectionString = "";
```
Az idézőjelek közé illessze be a korábban mentett kapcsolati sztring.
Keresse meg a metódust ReceiveSalesMessageAsync() . Ezen a metóduson belül keresse meg a kód alábbi sorát:
```
// Create a Service Bus client that will authenticate using a connection string
```
Ezt a sort cserélje le a következő kódra:
```
var client = new ServiceBusClient(ServiceBusConnectionString);
```

Az üzenetkezelési beállítások konfigurálásához keresse meg a következő kódsort:

// Create the options to use for configuring the processor

Cserélje le ezt a sort a következő kódsorra:

var processorOptions = new ServiceBusProcessorOptions
{
    MaxConcurrentCalls = 1,
    AutoCompleteMessages = false
};

Processzor létrehozásához keresse meg a következő kódsort:

// Create a processor that we can use to process the messages

Ezt a sort cserélje le a következő kódra:

await using ServiceBusProcessor processor = client.CreateProcessor(QueueName, processorOptions);

A kezelők konfigurálásához keresse meg a következő kódsort:

// Configure the message and error handler to use

Ezt a sort cserélje le a következő kódra:

processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;

A feldolgozás megkezdéséhez keresse meg a következő kódsort:
```
// Start processing
```
Ezt a sort cserélje le a következő kódra:
```
await processor.StartProcessingAsync();
```
A Service Bus-kapcsolat bezárásához keresse meg a következő kódsort:
```
// Close the processor here
```
Ezt a sort cserélje le a következő kódra:
```
await processor.CloseAsync();
```

Tekintse át a metódus kódját MessageHandler :

// handle received messages
static async Task MessageHandler(ProcessMessageEventArgs args)
{
    // extract the message
    string body = args.Message.Body.ToString();

    // print the message
    Console.WriteLine($"Received: {body}");

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

Tekintse át a metódus kódját ErrorHandler :

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

Ellenőrizze, hogy a privatemessagereceiver/Program.cs végleges kódja hasonlít-e a következő példára:

using System;
using System.Text;
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;

namespace privatemessagereceiver
{
    class Program
    {

        const string ServiceBusConnectionString = "Endpoint=sb://<examplenamespace.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
        const string QueueName = "salesmessages";

        static void Main(string[] args)
        {

            ReceiveSalesMessageAsync().GetAwaiter().GetResult();

        }

        static async Task ReceiveSalesMessageAsync()
        {

            Console.WriteLine("======================================================");
            Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
            Console.WriteLine("======================================================");


            var client = new ServiceBusClient(ServiceBusConnectionString);

            var processorOptions = new ServiceBusProcessorOptions
            {
                MaxConcurrentCalls = 1,
                AutoCompleteMessages = false
            };

            await using ServiceBusProcessor processor = client.CreateProcessor(QueueName, processorOptions);

            processor.ProcessMessageAsync += MessageHandler;
            processor.ProcessErrorAsync += ErrorHandler;


            await processor.StartProcessingAsync();

            Console.Read();

            await processor.CloseAsync();

        }

        // handle received messages
        static 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
        static Task ErrorHandler(ProcessErrorEventArgs args)
        {
            Console.WriteLine(args.Exception.ToString());
            return Task.CompletedTask;
        }
    }
}

A fájlt a Ctrl+S billentyűkombinációval mentse el, majd a Ctrl+Q billentyűkombinációval zárja be a szerkesztőt.

Üzenet fogadása az üzenetsorból

Az értékesítésről üzenetet kapó összetevő futtatásához futtassa ezt a parancsot a Cloud Shellben:
```
dotnet run --project privatemessagereceiver
```
Ellenőrizze az értesítéseket a Cloud Shellben. Az Azure Portalon nyissa meg a Service Bus-névteret, és ellenőrizze az Üzenetek diagramot:
```
Received: $10,000 order for bicycle parts from retailer Adventure Works.
```
Ha azt látja, hogy az üzenetek a Cloud Shellben érkeztek, nyomja le az Enter billentyűt az alkalmazás leállításához.

Az üzenetszám ellenőrzése

Futtassa a következő kódot annak megerősítéséhez, hogy az összes üzenet el lett távolítva az üzenetsorból, és ne felejtse el lecserélni <a névteret> a Service Bus-névtérre.

az servicebus queue show \
    --resource-group <rgn>[sandbox resource group name]</rgn> \
    --name salesmessages \
    --query messageCount \
    --namespace-name <namespace-name>

A kimenet az lesz 0 , ha az összes üzenet el lett távolítva.

Olyan kódot írt, amely üzenetet küld az egyes értékesítésekről egy Service Bus-üzenetsornak. A Salesforce elosztott alkalmazásban ezt a kódot kell írnia a mobilalkalmazásba, amelyet az értékesítők használnak az eszközökön.

Olyan kódot is írt, amely üzenetet fogad a Service Bus-üzenetsorból. A Salesforce elosztott alkalmazásban ezt a kódot az Azure-ban futó webszolgáltatásban kell írnia, és a fogadott üzeneteket feldolgozza.

Folytatás

Gyakorlat – Üzenetek küldése és fogadása üzenetsor használatával

A kapcsolati sztring lekérése a Service Bus névterébe

A kezdő szintű alkalmazás klónozása és megnyitása

Kód írása üzenet üzenetsorba való küldéséhez

Üzenet küldése az üzenetsorba

Kód írása az üzenetek üzenetsorból történő fogadásához

Üzenet fogadása az üzenetsorból

Az üzenetszám ellenőrzése

Visszajelzés