Többrétegű .NET-alkalmazás Azure Service Bus-üzenetsorok használatával

Cikk
10/18/2023

A Visual Studio és az ingyenes Azure SDK for .NET használatával könnyen fejleszthet a Microsoft Azure platformra. Ez az oktatóanyag végigvezeti egy olyan alkalmazás létrehozásának a lépésein, amely több, a helyi környezetben futó Azure-erőforrást használ.

Az alábbiakat fogja elsajátítani:

A számítógép felkészítése az Azure-fejlesztésre egyetlen letöltéssel és telepítéssel.
A Visual Studio használata az Azure platformra való fejlesztéshez.
Többrétegű alkalmazások létrehozása az Azure-ban webes és feldolgozói szerepkörök használatával.
A rétegek közötti kommunikáció módja Service Bus-üzenetsorok használatával.

Feljegyzés

Az oktatóanyag elvégzéséhez egy Azure-fiókra lesz szüksége. Aktiválhatja MSDN-előfizetői előnyeit, vagy regisztrálhat egy ingyenes fiókot.

Ebben az oktatóanyagban egy Azure-felhőszolgáltatásban fogja létrehozni és futtatni a többrétegű alkalmazást. Az előtér egy ASP.NET MVC webes szerepkör, a háttér pedig egy Service Bus-üzenetsort használó feldolgozói szerepkör. Ugyanezen többrétegű alkalmazást létrehozhatja úgy is, hogy az előtér olyan webes projekt legyen, amely a felhőszolgáltatás helyett egy Azure-webhelyen helyezhető üzembe. Elvégezheti a .NET helyszíni/felhőalapú hibridalkalmazással foglalkozó oktatóanyagot is.

Az alábbi képernyőképen az elkészült alkalmazás látható.

Application's Submit page

Forgatókönyv áttekintése: szerepkörök közötti kommunikáció

A feldolgozási kérés küldéséhez a webes szerepkörben futó előtér felhasználói felületi összetevőnek együtt kell működnie a feldolgozói szerepkörben futó középső rétegbeli logikával. Ez a példa Service Bus-üzenetkezelést használ a rétegek közötti kommunikációhoz.

A webes és a középső réteg között használt Service Bus-üzenetkezelés elválasztja a két összetevőt. A közvetlen üzenetküldés (azaz TCP vagy HTTP) ellenében a webes réteg nem csatlakozik közvetlenül a középső réteghez; ehelyett üzenetekként leküldi a munkaegységeket a Service Busba, amely megbízhatóan megőrzi őket, amíg a középső réteg készen nem áll a felhasználásukra és a feldolgozásukra.

A Service Bus kétfajta entitást biztosít a közvetítőalapú üzenettovábbítás támogatásához: üzenetsorokat és témaköröket. Az üzenetsorok esetén az egyes üzenetsorokra küldött üzeneteket egyetlen fogadó használja fel. A témakörök a közzététel/előfizetés mintát támogatják, amelyben az egyes közzétett üzenetek az adott témakörre való előfizetéssel érhetők el. Az egyes előfizetések logikai módon tartják fenn a saját üzenetsorukat. Az előfizetések konfigurálhatók szűrési szabályokkal is, amelyek az előfizetés üzenetsorába továbbított üzeneteket az adott szűrővel egyező üzenetekre korlátozzák. Az alábbi példa Service Bus-üzenetsorokat használ.

Diagram showing the communication between the Web Role, Service Bus, and the Worker Role.

Ennek a kommunikációs mechanizmusnak több előnye is van a közvetlen üzenettovábbítással szemben:

Időbeli elválasztás. Az aszinkron üzenetkezelési minta használatakor a gyártóknak és a fogyasztóknak nem kell egyszerre online állapotban lenniük. A Service Bus megbízhatóan tárolja az üzeneteket, amíg a felhasználó fél készen nem áll a fogadásukra. Ez lehetővé teszi az elosztott alkalmazás összetevőinek leválasztását, akár önkéntesen – például karbantartási céllal –, akár egy összetevő összeomlása miatt, anélkül, hogy ez az egész rendszerre hatással lenne. Emellett a felhasználó alkalmazásnak elég mindössze a nap bizonyos időpontjaiban online lennie.
Terheléskiegyenlítés. Számos alkalmazásban a rendszerterhelés időnként eltérő, míg az egyes munkaegységek feldolgozásához szükséges idő jellemzően állandó marad. Az üzenetek létrehozói és felhasználói közé üzenetsorokat helyezve a felhasználó alkalmazást (a feldolgozót) csak az átlagos terhelés, és nem a csúcsterhelés figyelembe vételével kell létrehozni. A bejövő terhelés változásával az üzenetsor hossza nő vagy csökken. Ez közvetlen megtakarításokkal jár az alkalmazásterhelés kiszolgálásához szükséges infrastruktúraméret költségei tekintetében.
Terheléselosztás. A terhelés növekedésével további feldolgozó folyamatok adhatók hozzá az üzenetsorból való olvasásra. Az egyes üzeneteket a feldolgozó folyamatoknak csak az egyike dolgozza fel. Továbbá ez a lekéréses alapú terheléselosztás lehetővé teszi a feldolgozó gépek optimális használatát akkor is, ha a feldolgozó gépek eltérőek a feldolgozási teljesítmény szempontjából, mivel az üzeneteket a saját maximális sebességükön fogják lekérni. Ezt a mintát gyakran a versengő felhasználó mintának hívják.

Az alábbi szakaszok az architektúrát megvalósító kódot ismertetik.

Előfeltételek

Ebben az oktatóanyagban a Microsoft Entra-hitelesítést fogja használni a létrehozáshoz ServiceBusClient és ServiceBusAdministrationClient az objektumokhoz. A használathoz és használathoz DefaultAzureCredential az alábbi lépéseket kell elvégeznie az alkalmazás helyi teszteléséhez egy fejlesztői környezetben.

Alkalmazás regisztrálása a Microsoft Entra-azonosítóban.
Adja hozzá az alkalmazást a Service Bus Data Owner szerepkörhöz.
Állítsa be a AZURE-CLIENT-ID, AZURE-TENANT-IDÉS AZURE-CLIENT-SECRET környezeti változókat. Utasításokat ebben a cikkben talál.

A Service Bus beépített szerepköreinek listáját a Service Bus beépített Azure-szerepkörei között találja.

Névtér létrehozása

Első lépésként hozzon létre egy névteret, és szerezze be a névtérhez tartozó közös hozzáférésű jogosultságkód (SAS) kulcsot. A névtér egy alkalmazáshatárt biztosít a Service Buson keresztül közzétett minden alkalmazáshoz. Az SAS-kulcsot a rendszer állítja elő a névtér létrehozásakor. A névtérnév és az SAS-kulcs együttes használata hitelesítő adatokat biztosít a Service Bus számára, amellyel hitelesíti a hozzáférést egy alkalmazáshoz.

Névtér létrehozása az Azure Portalon

A Service Bus-üzenetküldési entitások Azure-ban való használatának megkezdéséhez először létre kell hoznia egy, az Azure-ban egyedi névvel rendelkező névteret. A névtér egy hatókör-tárolót biztosít a Service Bus-erőforrásokhoz (üzenetsorokhoz, témakörökhöz stb.) az alkalmazásban.

Névtér létrehozása:

Jelentkezzen be az Azure Portalra.
Lépjen a Minden szolgáltatás lapra.
A bal oldali navigációs sávon válassza az Integráció lehetőséget a kategóriák listájából, vigye az egérmutatót a Service Bus fölé, majd válassza a + Service Bus csempén található gombot.
A Névtér létrehozása lap Alapszintű címkéjében kövesse az alábbi lépéseket:
1. Előfizetés esetén válassza ki azt az Azure-előfizetést, amelyben létre szeretné hozni a névteret.
2. Erőforráscsoport esetén válasszon ki egy meglévő erőforráscsoportot, amelyben a névtér él, vagy hozzon létre egy újat.
3. Adja meg a névtér nevét. A névtér nevének meg kell felelnie a következő elnevezési konvencióknak:
  - A névnek egyedinek kell lennie az Azure-ban. A rendszer azonnal ellenőrzi, hogy a név elérhető-e.
  - A név hossza legalább 6 és legfeljebb 50 karakter lehet.
  - A név csak betűket, számokat, "-" kötőjeleket tartalmazhat.
  - A névnek betűvel kell kezdődnie, és betűvel vagy számmal kell végződnie.
  - A név nem "-sb" vagy "-mgmt" végződésű.
4. A Hely területen válassza ki azt a régiót, amelyben a névteret üzemeltetni kell.
5. Tarifacsomag esetén válassza ki a névtérhez tartozó tarifacsomagot (Alapszintű, Standard vagy Prémium). Ebben a rövid útmutatóban válassza a Standard lehetőséget.
  
  Fontos
  
  Ha témaköröket és előfizetéseket szeretne használni, válassza a Standard vagy a Premium lehetőséget. Az alapszintű tarifacsomag nem támogatja a témaköröket/előfizetéseket.
  
  Ha a Prémium tarifacsomagot választotta, adja meg az üzenetkezelési egységek számát. A prémium szint erőforrás-elkülönítést biztosít a CPU és a memória szintjén, így minden számítási feladat külön fut. Ennek az erőforrás-tárolónak a neve üzenetkezelési egység. A prémium szintű névtér legalább egy üzenetkezelési egységgel rendelkezik. Minden Service Bus Premium-névtérhez választhat 1, 2, 4, 8 vagy 16 üzenetkezelési egységet. További információ: Service Bus Premium Messaging.
6. Válassza a Véleményezés + létrehozás lehetőséget a lap alján.
7. A Véleményezés + létrehozás lapon tekintse át a beállításokat, és válassza a Létrehozás lehetőséget.
Miután az erőforrás üzembe helyezése sikeres volt, válassza az Erőforrás megnyitása lehetőséget az üzembe helyezési lapon.
Megjelenik a service bus-névtér kezdőlapja.

Kapcsolati sztring lekérése a névtérbe (Azure Portal)

Új névtér létrehozása automatikusan létrehoz egy kezdeti közös hozzáférésű jogosultságkód-(SAS- ) szabályzatot elsődleges és másodlagos kulcsokkal, valamint elsődleges és másodlagos kapcsolati sztring, amelyek mindegyike teljes körű ellenőrzést biztosít a névtér minden aspektusa felett. A Service Bus-hitelesítéssel és -engedélyezéssel kapcsolatos információkért tekintse meg a normál feladók és fogadók számára korlátozottabb jogosultságokkal rendelkező szabályok létrehozását.

Az ügyfél a kapcsolati sztring használatával csatlakozhat a Service Bus-névtérhez. A névtér elsődleges kapcsolati sztring másolásához kövesse az alábbi lépéseket:

A Service Bus Névtér lapján válassza a megosztott hozzáférési szabályzatokat a bal oldali menüben.
A Megosztott hozzáférési szabályzatok lapon válassza a RootManageSharedAccessKey lehetőséget.
A Házirend: RootManageSharedAccessKey ablakban válassza az Elsődleges Csatlakozás ion-sztring melletti másolás gombot a kapcsolati sztring későbbi használatra a vágólapra másolásához. Illessze be ezt az értéket a Jegyzettömbbe vagy egy másik ideiglenes helyre.

Ezen a lapon másolhatja az elsődleges kulcsot, a másodlagos kulcsot, az elsődleges kapcsolati sztring és a másodlagos kapcsolati sztring.

Webes szerepkör létrehozása

Ebben a szakaszban az alkalmazás előtérrendszerét hozza létre. Először létrehozza az alkalmazás által megjelenített oldalakat. Ezt követően hozzáadja a kódot, amely elemeket küld el a Service Bus-üzenetsorba, és megjeleníti az üzenetsor állapotára vonatkozó információkat.

A projekt létrehozása

Rendszergazdai jogosultságokkal indítsa el a Visual Studiót: kattintson a jobb gombbal a Visual Studio program ikonra, majd válassza a Futtatás rendszergazdaként lehetőséget. A cikk későbbi részében tárgyalt Azure Compute Emulator használatához rendszergazdai jogosultságokkal kell kezdeni a Visual Studiót.

A Visual Studio Fájl menüjében válassza az Új, majd a Projekt elemet.
A Sablonok lapon kövesse az alábbi lépéseket:
1. A programozási nyelvhez válassza a C# lehetőséget.
2. Válassza a Felhő lehetőséget a projekttípushoz.
3. Válassza az Azure Cloud Service lehetőséget.
4. Válassza a Tovább lehetőséget.
Nevezze el a multiTierApp projektet, válassza ki a projekt helyét, majd válassza a Létrehozás lehetőséget.
A Szerepkörök lapon kattintson duplán ASP.NET webes szerepkörre, és válassza az OK gombot.
Mutasson a WebRole1 fölé az Azure Cloud Service-megoldás alatt, válassza a ceruza ikont, és nevezze át a webes szerepkört FrontendWebRole-ra. Ezután válassza az OK gombra. (Ügyeljen, hogy a „Frontend” nevet kis „e” betűvel írja, és ne „FrontEnd” formában.)
Az Új ASP.NET webalkalmazás létrehozása párbeszédpanelen válassza az MVC, majd a Létrehozás lehetőséget.
A Megoldáskezelő FrontendWebRole projektben kattintson a jobb gombbal a Hivatkozások elemre, majd válassza a NuGet-csomagok kezelése lehetőséget.
Válassza a Tallózás lapot, majd keresse meg az Azure.Messaging.ServiceBus szolgáltatást. Válassza ki az Azure.Messaging.ServiceBus csomagot, válassza a Telepítés lehetőséget, és fogadja el a használati feltételeket.

Vegye figyelembe, hogy a rendszer létrehozta a szükséges ügyfélszerelvényekre mutató hivatkozásokat, és hozzáadott néhány új kódfájlt.
Ugyanezeket a lépéseket követve adja hozzá a Azure.Identity NuGet-csomagot a projekthez.
A Megoldáskezelő bontsa ki a FronendWebRole elemet, kattintson a jobb gombbal a Modellek elemre, és válassza a Hozzáadás, majd az Osztály lehetőséget. A Name (Név) mezőbe írja be az OnlineOrder.cs nevet. Ezután válassza a Hozzáadás elemet.

A webes szerepkör kódjának megírása

Ebben a szakaszban az alkalmazás által megjelenített különféle oldalakat hozza létre.

A Visual Studióban az OnlineOrder.cs fájlban cserélje le a meglévő névtér-definíciót az alábbi kódra:

namespace FrontendWebRole.Models
{
    public class OnlineOrder
    {
        public string Customer { get; set; }
        public string Product { get; set; }
    }
}

A Megoldáskezelőben kattintson duplán a Controllers\HomeController.cs elemre. Adja hozzá az alábbi using utasításokat a fájl elejéhez a névtereknek az imént létrehozott modellbe, valamint a Service Busba való foglalásához.
```
 using FrontendWebRole.Models;
 using Azure.Messaging.ServiceBus;    
```

Szintén a Visual Studióban a HomeController.cs fájlban cserélje le a meglévő névtér-definíciót az alábbi kódra. A kód az elemeknek az üzenetsorba való küldésének kezelésére vonatkozó metódusokat tartalmaz.

namespace FrontendWebRole.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            // Simply redirect to Submit, since Submit will serve as the
            // front page of this application.
            return RedirectToAction("Submit");
        }

        public ActionResult About()
        {
            return View();
        }

        // GET: /Home/Submit.
        // Controller method for a view you will create for the submission
        // form.
        public ActionResult Submit()
        {
            // Will put code for displaying queue message count here.

            return View();
        }

        // POST: /Home/Submit.
        // Controller method for handling submissions from the submission
        // form.
        [HttpPost]
        // Attribute to help prevent cross-site scripting attacks and
        // cross-site request forgery.  
        [ValidateAntiForgeryToken]
        public ActionResult Submit(OnlineOrder order)
        {
            if (ModelState.IsValid)
            {
                // Will put code for submitting to queue here.

                return RedirectToAction("Submit");
            }
            else
            {
                return View(order);
            }
        }
    }
}

A Build menüben válassza a Build Solution (Megoldás létrehozása) lehetőséget a munkája eddigi pontosságának teszteléséhez.
Most hozza létre a korábban létrehozott Submit() metódus nézetét. Kattintson a jobb gombbal a Submit() metóduson belül (ennek túlterhelése Submit() nem vesz figyelembe paramétereket) a HomeController.cs fájlban, majd válassza a Nézet hozzáadása parancsot.
Az Új elem hozzáadása párbeszédpanelen válassza a Hozzáadás lehetőséget.
A Nézet hozzáadása párbeszédpanelen hajtsa végre az alábbi lépéseket:
1. A Template (Sablon) listában válassza a Create (Létrehozás) lehetőséget.
2. A Model class (Modellosztály) listában válassza az OnlineOrder osztályt.
3. Válassza a Hozzáadás lehetőséget.
Módosítsa az alkalmazás megjelenő nevét. A Megoldáskezelő kattintson duplán a Views\Shared\_Layout.cshtml fájlra a Visual Studio szerkesztőjében való megnyitásához.
Cserélje le a My ASP.NET Application (Saját ASP.NET-alkalmazás) minden előfordulását Northwind Traders Products (Northwind Traders-termékek) értékre.
Távolítsa el a Home (Kezdőlap), About (Névjegy) és Contact (Kapcsolatfelvétel) hivatkozásokat. Törölje a kiemelt kódot:
Végül módosítsa úgy az elküldési lapot, hogy az megjelenítse az üzenetsorral kapcsolatos információkat. A Megoldáskezelőben kattintson duplán a Views\Home\Submit.cshtml fájlra a Visual Studio-szerkesztőben való megnyitásához. Adja hozzá a következő sort a <h2>Submit</h2> után. A ViewBag.MessageCount jelenleg üres. Később fel fogja tölteni.
```
<p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
```
Megvalósította a felhasználói felületet. Az F5 billentyű lenyomásával futtathatja az alkalmazást, és ellenőrizheti, hogy várakozásainak megfelelően jelenik-e meg.

Az elemeknek a Service Bus-üzenetsorba történő elküldésére szolgáló kód megírása

Adja hozzá az elemeknek a Service Bus-üzenetsorba történő elküldésére szolgáló kódot. Először hozza létre a Service Bus-üzenetsor kapcsolati adatait tartalmazó osztályt. Ezután inicializálja a kapcsolatot a Global.aspx.cs osztályból. Végül frissítse a korábban a HomeController.cs osztályban létrehozott elküldési kódot az elemek tényleges elküldéséhez a Service Bus-üzenetsorba.

A Megoldáskezelőben kattintson a jobb gombbal a FrontendWebRole projektre (a projektre, ne a szerepkörre kattintson a jobb gombbal). Válassza a Hozzáadás, majd az Osztály lehetőséget.
Adja az osztálynak a QueueConnector.cs nevet. Válassza a Hozzáadás lehetőséget az osztály létrehozásához.

Adja hozzá a kapcsolati adatokat tartalmazó és a Service Bus-üzenetsorral létesített kapcsolatot inicializáló kódot. Cserélje le a QueueConnector.cs teljes tartalmát a következő kódra, és adjon meg értéket a your Service Bus namespace (névtér neve) és a yourKey számára, amely az az elsődleges kulcs, amelyet korábban az Azure Portalon szerzett be.

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using System.Threading.Tasks;
 using Azure.Messaging.ServiceBus;
 using Azure.Messaging.ServiceBus.Administration;

namespace FrontendWebRole
{
     public static class QueueConnector
     {
         // object to send messages to a Service Bus queue
         internal static ServiceBusSender SBSender;

         // object to create a queue and get runtime properties (like message count) of queue
         internal static ServiceBusAdministrationClient SBAdminClient;

         // Fully qualified Service Bus namespace
         private const string FullyQualifiedNamespace = "<SERVICE BUS NAMESPACE NAME>.servicebus.windows.net";

         // The name of your queue.
         internal const string QueueName = "OrdersQueue";

         public static async Task Initialize()
         {
             // Create a Service Bus client that you can use to send or receive messages
             ServiceBusClient SBClient = new ServiceBusClient(FullyQualifiedNamespace, new DefaultAzureCredential());

             // Create a Service Bus admin client to create queue if it doesn't exist or to get message count
             SBAdminClient = new ServiceBusAdministrationClient(FullyQualifiedNamespace, new DefaultAzureCredential());

             // create the OrdersQueue if it doesn't exist already
             if (!(await SBAdminClient.QueueExistsAsync(QueueName)))
             {
                 await SBAdminClient.CreateQueueAsync(QueueName);
             }

             // create a sender for the queue 
             SBSender = SBClient.CreateSender(QueueName);    
         }
     }    
}

Ellenőrizze, hogy az Initialize metódus meghívása megtörténik. A Megoldáskezelőben kattintson duplán a Global.asax\Global.asax.cs elemre.
Adja hozzá az alábbi kódsort az Application_Start metódus végén.
```
 FrontendWebRole.QueueConnector.Initialize().Wait();
```
Végül frissítse a korábban létrehozott webkódot az elemek elküldéséhez az üzenetsorba. A Megoldáskezelőben kattintson duplán a Controllers\HomeController.cs elemre.

Frissítse a Submit() metódust (a paraméterekkel nem rendelkező túlterhelést) az alábbiak szerint, hogy megkapja az üzenetsorban lévő üzenetek számát.

     public ActionResult Submit()
     {
         QueueRuntimeProperties properties = QueueConnector.adminClient.GetQueueRuntimePropertiesAsync(QueueConnector.queueName).Result;
         ViewBag.MessageCount = properties.ActiveMessageCount;

         return View();
     }

Frissítse a Submit(OnlineOrder order) metódust (az egy paraméterrel rendelkező túlterhelést) az alábbiak szerint, hogy elküldje a rendelésinformációkat az üzenetsorba.

     public ActionResult Submit(OnlineOrder order)
     {
         if (ModelState.IsValid)
         {
             // create a message 
             var message = new ServiceBusMessage(new BinaryData(order));

             // send the message to the queue
             QueueConnector.sbSender.SendMessageAsync(message);

             return RedirectToAction("Submit");
         }
         else
         {
             return View(order);
         }
     }

Most ismét futtathatja az alkalmazást. Minden egyes alkalommal, amikor elküld egy rendelést, az üzenetek száma nőni fog.

A feldolgozói szerepkör létrehozása

Ekkor létrehozza a rendelésbeküldéseket feldolgozó feldolgozói szerepkört. Ez a példa a Worker Role with Service Bus Queue (Feldolgozói szerepkör Service Bus-üzenetsorral) Visual Studio-projektsablont használja. A szükséges hitelesítő adatokat már beszerezte a portálról.

Ellenőrizze, hogy társította-e a Visual Studiót az Azure-fiókjával.
A Visual Studio Megoldáskezelőjében kattintson a jobb gombbal a Roles (Szerepkörök) mappára a MultiTierApp projekt alatt.
Válassza a Hozzáadás, majd az Új feldolgozói szerepkör projekt lehetőséget. Megjelenik az Add New Role Project (Új szerepkör projekt hozzáadása) párbeszédpanel.
Az Új szerepkör-projekt hozzáadása párbeszédpanelen válassza a Feldolgozói szerepkör lehetőséget. Ne válassza ki a Service Bus-üzenetsort használó feldolgozói szerepkört, mert az az örökölt Service Bus SDK-t használó kódot hoz létre.
A Name (Név) mezőben adja az OrderProcessingRole nevet a projektnek. Ezután válassza a Hozzáadás elemet.
A Megoldáskezelő kattintson a jobb gombbal az OrderProcessingRole projektre, és válassza a NuGet-csomagok kezelése lehetőséget.
Válassza a Tallózás lapot, majd keresse meg az Azure.Messaging.ServiceBus szolgáltatást. Válassza ki az Azure.Messaging.ServiceBus csomagot, válassza a Telepítés lehetőséget, és fogadja el a használati feltételeket.
Ugyanezeket a lépéseket követve adja hozzá a Azure.Identity NuGet-csomagot a projekthez.
Hozza létre az OnlineOrder osztályt az üzenetsorból feldolgozott rendelések jelölésére. Használhat egy korábban létrehozott osztályt. A Megoldáskezelőben kattintson a jobb gombbal az OrderProcessingRole osztályra (az osztály ikonjára, ne a szerepkörre kattintson a jobb gombbal). Válassza a Hozzáadás, majd a Meglévő elem lehetőséget.
Nyissa meg a FrontendWebRole\Models almappát, majd kattintson duplán az OnlineOrder.cs elemre a projekthez való hozzáadásához.

Adja hozzá a következő using utasítást az OrderProcessingRole projekt WorkerRole.cs fájljába.

using FrontendWebRole.Models;
using Azure.Messaging.ServiceBus;
using Azure.Messaging.ServiceBus.Administration;

A WorkerRole.cs adja hozzá a következő tulajdonságokat.

Fontos

Használja a kapcsolati sztring az előfeltételek részeként feljegyzett névtérhez.

    // Fully qualified Service Bus namespace
    private const string FullyQualifiedNamespace = "<SERVICE BUS NAMESPACE NAME>.servicebus.windows.net";

    // The name of your queue.
    private const string QueueName = "OrdersQueue";

    // Service Bus Receiver object to receive messages message the specific queue
    private ServiceBusReceiver SBReceiver;

Frissítse a OnStart metódust, hogy létrehozhasson egy ServiceBusClient objektumot, majd egy ServiceBusReceiver objektumot, amely üzeneteket fogad a OrdersQueue.

    public override bool OnStart()
    {
        // Create a Service Bus client that you can use to send or receive messages
        ServiceBusClient SBClient = new ServiceBusClient(FullyQualifiedNamespace, new DefaultAzureCredential());

        CreateQueue(QueueName).Wait();

        // create a receiver that we can use to receive the message
        SBReceiver = SBClient.CreateReceiver(QueueName);

        return base.OnStart();
    }
    private async Task CreateQueue(string queueName)
    {
        // Create a Service Bus admin client to create queue if it doesn't exist or to get message count
        ServiceBusAdministrationClient SBAdminClient = new ServiceBusAdministrationClient(FullyQualifiedNamespace, new DefaultAzureCredential());

        // create the OrdersQueue if it doesn't exist already
        if (!(await SBAdminClient.QueueExistsAsync(queueName)))
        {
            await SBAdminClient.CreateQueueAsync(queueName);
        }
    }

Frissítse a metódust RunAsync úgy, hogy tartalmazza a kódot az üzenetek fogadásához.

    private async Task RunAsync(CancellationToken cancellationToken)
    {
        // TODO: Replace the following with your own logic.
        while (!cancellationToken.IsCancellationRequested)
        {
            // receive message from the queue
            ServiceBusReceivedMessage receivedMessage = await SBReceiver.ReceiveMessageAsync();

            if (receivedMessage != null)
            {
                Trace.WriteLine("Processing", receivedMessage.SequenceNumber.ToString());

                // view the message as an OnlineOrder
                OnlineOrder order = receivedMessage.Body.ToObjectFromJson<OnlineOrder>();
                Trace.WriteLine(order.Customer + ": " + order.Product, "ProcessingMessage");

                // complete message so that it's removed from the queue
                await SBReceiver.CompleteMessageAsync(receivedMessage);
            }
        }
    }

Befejezte az alkalmazást. A teljes alkalmazás teszteléséhez kattintson a jobb gombbal a MultiTierApp projektre a Megoldáskezelőben, válassza a Set as Startup Project (Beállítás kezdőprojektként) lehetőséget, majd nyomja le az F5 billentyűt. Az üzenetszám nem növekszik, mert a feldolgozói szerepkör feldolgozza az elemeket az üzenetsorból, és készként jelöli meg őket. A feldolgozói szerepkör nyomkövetési kimenetét az Azure Compute Emulator felhasználói felületén tekintheti meg. Ehhez kattintson a jobb gombbal az emulátor ikonjára a tálca értesítési területén, és válassza a Show Compute Emulator UI (A Compute Emulator felhasználói felületének megjelenítése) lehetőséget.

Következő lépések

A Service Busról a következő forrásanyagokban találhat további információkat: