.NET-Anwendungen mit mehreren Ebenen unter Verwendung von Azure Service Bus-Warteschlangen

Artikel
05/12/2023

Mit Visual Studio und dem kostenlosen Azure SDK für .NET können Sie schnell und einfach für Microsoft Azure entwickeln. In diesem Tutorial werden Sie durch die Schritte zum Erstellen einer Anwendung geführt, von der mehrere in der lokalen Umgebung ausgeführte Azure-Ressourcen verwendet werden.

Sie lernen Folgendes:

Vorbereitung Ihres Computers für die Azure-Entwicklung mit einem einzigen Download und einer einzigen Installation
Einsatz von Visual Studio für die Azure-Entwicklung
Erstellung von Anwendungen mit mehreren Ebenen in Azure mit Web- und Arbeiterrollen
Kommunikation zwischen Ebenen mithilfe von Service Bus-Warteschlangen

Hinweis

Um dieses Tutorial abzuschließen, benötigen Sie ein Azure-Konto. Sie können Ihre MSDN-Abonnentenleistungen aktivieren oder sich für ein kostenloses Testkonto registrieren.

In diesem Tutorial werden Sie eine mehrschichtige Anwendung in einem Azure-Clouddienst erstellen und ausführen. Als Front-End dient eine ASP.NET MVC-Webrolle, und als Back-End eine Workerrolle, die eine Service Bus-Warteschlange nutzt. Dieselbe Anwendung mit mehreren Ebenen kann auch mit einem Webprojekt als Front-End erstellt und auf einer Azure-Website anstelle eines Cloud-Diensts bereitgestellt werden. Sie können auch das Tutorial Hybride lokale/Cloud-.NET-Anwendung ausprobieren.

Der folgende Screenshot zeigt die fertige Anwendung.

Application's Submit page

Szenario-Übersicht: Kommunikation zwischen Rollen

Um eine Bestellung zur Verarbeitung zu übermitteln, muss die Front-End-GUI in ihrer Funktion als Webrolle mit der Logikkomponente in der mittleren Ebene interagieren, die eine Workerrolle erfüllt. In diesem Beispiel wird Service Bus-Messaging für die Kommunikation zwischen Ebenen verwendet.

Durch die Nutzung von Service Bus-Messaging zwischen Web- und mittlerer Ebene werden die beiden Komponenten voneinander entkoppelt. Im Gegensatz zum direkten Messaging (z. B. über TCP oder HTTP) verbindet sich die Webebene nicht direkt mit der mittleren Ebene, sondern pusht Arbeitseinheiten in Form von Nachrichten in Service Bus. Dort werden diese zuverlässig aufbewahrt, bis die mittlere Ebene diese nutzen und verarbeiten kann.

Service Bus bietet zwei Entitäten für das Brokermessaging: Warteschlangen und Themen. Mit Warteschlangen wird jede Nachricht von einem einzelnen Empfänger konsumiert. Themen unterstützen das Veröffentlichungs- und Abonnementmuster, mit dem jede veröffentlichte Nachricht den für das entsprechende Thema registrierten Abonnements zugänglich gemacht wird. Jedes Abonnement pflegt eine eigene Nachrichten-Warteschlange. Abonnements können mit Filterregeln konfiguriert werden. Diese sorgen dafür, dass nur Nachrichten in der Abonnement-Warteschlange landen, welche die Filterregeln erfüllen. Das folgende Beispiel verwendet Service Bus-Warteschlangen.

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

Dieser Kommunikationsmechanismus bietet verschiedene Vorteile gegenüber direkten Nachrichten:

Zeitliche Entkopplung: Wenn Sie das asynchrone Messagingmuster verwenden, müssen Producer und Consumer nicht gleichzeitig online sein. Der Servicebus speichert die Nachrichten zuverlässig, bis der Consumer diese entgegennehmen kann. Auf diese Weise können die Komponenten verteilter Anwendungen voneinander entkoppelt werden, z. B. zu Wartungszwecken oder bei einem Komponentenausfall, ohne das Gesamtsystem zu beeinträchtigen. Außerdem genügt es unter Umständen, wenn die konsumierende Anwendung nur zu bestimmten Tageszeiten online ist.
Lastenausgleich: In vielen Anwendungen schwankt die Systemlast mit der Zeit, während die Bearbeitungszeit pro Arbeitseinheit normalerweise konstant ist. Durch die Einführung einer Warteschlange zwischen Nachrichtenproducer und Consumer muss der Consumer (Arbeiter) anstatt der Spitzenlast nur die durchschnittliche Last verarbeiten können. Die Tiefe der Warteschlange erhöht und verringert sich mit der eingehenden Last. Dies ermöglicht direkte Einsparungen bei der Infrastruktur, die zur Bearbeitung der Anwendungslast benötigt wird.
Lastenausgleich. Mit zunehmender Last können zusätzliche Arbeitsprozesse zur Verarbeitung der Warteschlange eingesetzt werden. Jede Nachricht wird nur von einem der Arbeitsprozesse verarbeitet. Außerdem ermöglicht dieser pullbasierte Lastenausgleich eine optimale Auslastung der Workercomputer, selbst wenn sich deren Rechenleistung stark unterscheidet, da jeder Workercomputer die Nachrichten mit seinem eigenen Maximaldurchsatz aus der Warteschlange pullt. Dieses Muster nennt man auch konkurrierende Consumer.

In den folgenden Abschnitten wird der Code für die Implementierung dieser Architektur behandelt.

Voraussetzungen

In diesem Tutorial wird die Microsoft Entra-Authentifizierung verwendet, um ServiceBusClient- und ServiceBusAdministrationClient-Objekte zu erstellen. Sie verwenden außerdem DefaultAzureCredential. Dazu müssen Sie die folgenden Schritte ausführen, um die Anwendung lokal in einer Entwicklungsumgebung zu testen.

Registrieren Sie eine Anwendung in Microsoft Entra ID.
Fügen Sie die Anwendung der Rolle Service Bus Data Owner hinzu.
Legen Sie die Umgebungsvariablen AZURE-CLIENT-ID, AZURE-TENANT-ID und AZURE-CLIENT-SECRET fest. Anweisungen finden Sie in diesem Artikel.

Eine Liste der integrierten Service Bus-Rollen finden Sie unter Integrierte Azure-Rollen für Service Bus.

Erstellen eines Namespace

Der erste Schritt besteht im Erstellen eines Namespace und Abrufen eines SAS-Schlüssels (Shared Access Signature) für diesen Namespace. Ein Namespace stellt eine Anwendungsgrenze für jede Anwendung bereit, die über Service Bus zur Verfügung steht. Das System generiert einen SAS-Schlüssel, wenn ein Namespace erstellt wird. Namespace-Name und SAS-Schlüssel bilden gemeinsam die Anmeldeinformationen, mit denen sich der Service Bus bei der Anwendung authentifiziert.

Erstellen eines Namespace im Azure-Portal

Um mit der Verwendung von Service Bus-Nachrichtenentitäten in Azure beginnen zu können, müssen Sie zuerst einen Namespace mit einem in Azure eindeutigen Namen erstellen. Ein Namespace ist ein Bereichscontainer für Service Bus-Ressourcen (Warteschlangen, Themen usw.) innerhalb Ihrer Anwendung.

So erstellen Sie einen Namespace

Melden Sie sich beim Azure-Portal an.
Navigieren Sie zur Seite Alle Dienste.
Wählen Sie im linken Navigationsbereich in der Kategorienliste Integration aus, zeigen Sie mit dem Mauszeiger auf Service Bus, und wählen Sie auf der Service Bus-Kachel die Schaltfläche + aus.
Führen Sie auf der Seite Namespace erstellen auf der Registerkarte Grundlagen die folgenden Schritte aus:
1. Wählen Sie unter Abonnement ein Azure-Abonnement aus, in dem der Namespace erstellt werden soll.
2. Wählen Sie unter Ressourcengruppe eine vorhandene Ressourcengruppe für den Namespace aus, oder erstellen Sie eine neue Ressourcengruppe.
3. Geben Sie einen Namen für den Namespace ein. Der Namespacename sollte den folgenden Namenskonventionen entsprechen:
  - Der Name muss innerhalb von Azure eindeutig sein. Das System überprüft sofort, ob dieser Name verfügbar ist.
  - Die Länge des Namens beträgt mindestens 6 und maximal 50 Zeichen.
  - Der Name darf nur Buchstaben, Zahlen und Bindestriche („-“) enthalten.
  - Der Name muss mit einem Buchstaben beginnen und mit einem Buchstaben oder einer Ziffer enden.
  - Der Name endet nicht mit „-sb“ oder „-mgmt“.
4. Wählen Sie unter Standort die Region aus, in der Ihr Namespace gehostet werden soll.
5. Wählen Sie unter Tarif den Tarif (Basic, Standard oder Premium) für den Namespace aus. Wählen Sie für diesen Schnellstart die Option Standard aus.
  
  Wichtig
  
  Wenn Sie Themen und Abonnements nutzen möchten, wählen Sie entweder Standard oder Premium aus. Themen/Abonnements werden für den Basic-Tarif nicht unterstützt.
  
  Wenn Sie den Tarif Premium auswählen, geben Sie die Anzahl von Messagingeinheiten an. Der Premium-Tarif bietet Ressourcenisolierung auf CPU- und Arbeitsspeicherebene, sodass die einzelnen Workloads voneinander isoliert ausgeführt werden. Dieser Ressourcencontainer wird als Messagingeinheit bezeichnet. Ein Premium-Namespace verfügt über mindestens eine Messagingeinheit. Sie können 1, 2, 4, 8 oder 16 Messagingeinheiten für jeden Service Bus Premium-Namespace auswählen. Weitere Informationen finden Sie unter Service Bus Premium- und Standard-Preisstufe für Messaging.
6. Wählen Sie am unteren Rand der Seite die Option Bewerten + erstellen aus.
7. Überprüfen Sie die Einstellungen auf der Seite Überprüfen und erstellen, und wählen Sie Erstellen aus.
Wählen Sie nach der erfolgreichen Bereitstellung der Ressource auf der Bereitstellungsseite Zur Ressource wechseln aus.
Die Startseite für Ihren Service Bus-Namespace wird angezeigt.

Abrufen der Verbindungszeichenfolge zum Namespace (Azure-Portal)

Beim Erstellen eines neuen Namespace wird automatisch eine anfängliche SAS-Richtlinie (Shared Access Signature) mit primären und sekundären Schlüsseln sowie primären und sekundären Verbindungszeichenfolgen generiert, mit denen Sie jeweils die volle Kontrolle über sämtliche Aspekte des Namespace haben. Unter Service Bus-Authentifizierung und -Autorisierung erfahren Sie, wie Sie Regeln mit stärker eingeschränkten Rechten für reguläre Absender und Empfänger erstellen.

Ein Client kann die Verbindungszeichenfolge verwenden, um eine Verbindung mit dem Service Bus-Namespace herzustellen. Führen Sie die folgenden Schritte aus, um die primäre Verbindungszeichenfolge für Ihren Namespace zu kopieren:

Wählen Sie auf der Seite Service Bus-Namespace im linken Menü die Option Freigegebene Zugriffsrichtlinien aus.
Wählen Sie auf der Seite Freigegebene Zugriffsrichtlinien die Option RootManageSharedAccessKey aus.
Wählen Sie im Fenster Richtlinie: RootManageSharedAccessKey neben Primäre Verbindungszeichenfolge die Schaltfläche „Kopieren“ aus, um die Verbindungszeichenfolge zur späteren Verwendung in die Zwischenablage zu kopieren. Fügen Sie diesen Wert in den Editor oder an einem anderen temporären Speicherort ein.

Auf dieser Seite können Sie den Primärschlüssel, den sekundären Schlüssel, die primäre Verbindungszeichenfolge und die sekundäre Verbindungszeichenfolge kopieren.

Erstellen einer Webrolle

In diesem Abschnitt lernen Sie, wie Sie das Front-End Ihrer Anwendung erstellen. Zunächst erstellen Sie die Seiten, aus denen Ihre Anwendung besteht. Anschließend fügen Sie Code hinzu, mit dem Elemente an eine Service Bus-Warteschlange übermittelt und Statusinformationen zur Warteschlange angezeigt werden.

Erstellen des Projekts

Starten Sie Visual Studio mit Administratorrechten: Klicken Sie mit der rechten Maustaste auf das Programmsymbol von Visual Studio, und wählen Sie anschließend Als Administrator ausführen aus. Für den ebenfalls in diesem Artikel behandelten Azure-Serveremulator muss Visual Studio mit Administratorrechten gestartet werden.

Wählen Sie in Visual Studio im Menü Datei die Option Neu aus, und wählen Sie dann Projekt aus.
Führen Sie auf der Seite Vorlagen die folgenden Schritte aus:
1. Wählen Sie als Programmiersprache C# aus.
2. Wählen Sie als Projekttyp Cloud aus.
3. Wählen Sie Azure-Clouddienst aus.
4. Wählen Sie Weiter aus.
Nennen Sie das Projekt MultiTierApp, und wählen Sie den Speicherort für das Projekt und dann Erstellen aus.
Doppelklicken Sie auf der Seite Rollen auf ASP.NET-Webrolle, und wählen Sie OK aus.
Zeigen Sie auf WebRole1 unter Azure-Clouddienstlösung, wählen Sie das Stiftsymbol aus, und geben Sie der Webrolle den Namen FrontendWebRole. Klicken Sie anschließend auf OK. (Achten Sie darauf „Frontend“ mit kleinem „e“ einzugeben, nicht als „FrontEnd“.)
Wählen Sie im Dialogfeld Neue ASP.NET-Webanwendung erstellen die Option MVC und dann Erstellen aus.
Klicken Sie im Projektmappen-Explorer im Projekt FrontendWebRole mit der rechten Maustaste auf Verweise, und wählen Sie dann NuGet-Pakete verwalten aus.
Wählen Sie die Registerkarte Durchsuchen aus, und suchen Sie nach Azure.Messaging.ServiceBus. Wählen Sie das Paket Azure.Messaging.ServiceBus und dann Installieren aus, und akzeptieren Sie die Nutzungsbedingungen.

Beachten Sie, dass die benötigten Clientassemblys nun referenziert sind und einige neue Codedateien hinzugefügt wurden.
Führen Sie die gleichen Schritte aus, um dem Projekt das NuGet-Paket Azure.Identity hinzuzufügen.
Erweitern Sie im Projektmappen-Explorer den Eintrag FrontendWebRole, klicken Sie mit der rechten Maustaste auf Modelle, und wählen Sie dann Hinzufügen und Klasse aus. Geben Sie in das Feld Name den Namen OnlineOrder.cs ein. Wählen Sie anschließend Hinzufügen.

Schreiben des Codes für Ihre Webrolle

In diesem Abschnitt erstellen Sie die verschiedenen Seiten, aus denen Ihre Anwendung besteht.

Ersetzen Sie in der Datei "OnlineOrder.cs" in Visual Studio die bestehende Namespacedefinition durch den folgenden Code:

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

Doppelklicken Sie im Projektmappen-Explorer auf Controllers\HomeController.cs. Fügen Sie die folgenden using-Anweisungen am Anfang Ihrer Datei hinzu, um die Namespaces für Ihr neu erstelltes Modell sowie Service Bus einzuschließen.
```
 using FrontendWebRole.Models;
 using Azure.Messaging.ServiceBus;    
```

Ersetzen Sie in der Datei "HomeController.cs" in Visual Studio die bestehende Namespacedefinition ebenfalls durch den folgenden Code. Dieser Code enthält die Methoden für die Übermittlung von Elementen in die Warteschlange.

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

Wählen Sie im Menü Build die Option Projektmappe erstellen aus, um die Genauigkeit Ihrer bisherigen Arbeit zu überprüfen.
Erstellen Sie anschließend die Ansicht für die zuvor erstellte Submit()-Methode. Klicken Sie mit der rechten Maustaste in die Submit()-Methode (Überladung von Submit() ohne Parameter), und wählen Sie in der Datei HomeController.cs die Option Ansicht hinzufügen aus.
Wählen Sie im Dialogfeld Neues Gerüstelement hinzufügen die Option Hinzufügen aus.
Führen Sie im Dialogfeld Ansicht hinzufügen die folgenden Schritte aus:
1. Wählen Sie in der Liste Vorlage die Option Erstellen aus.
2. Wählen Sie in der Liste Modellklasse die OnlineOrder-Klasse aus.
3. Klicken Sie auf Hinzufügen.
Ändern Sie nun den angezeigten Namen Ihrer Anwendung. Doppelklicken Sie im Projektmappen-Explorer auf die Datei Views\Shared\_Layout.cshtml, um sie im Visual Studio-Editor zu öffnen.
Ersetzen Sie alle Vorkommnisse von My ASP.NET Application durch Northwind Traders Products.
Entfernen Sie die Links Home, About und Contact. Löschen Sie den hervorgehobenen Code:
Erweitern Sie anschließend die Übermittlungsseite um einige Informationen zur Warteschlange. Doppelklicken Sie im Projektmappen-Explorer auf die Datei Views\Home\Submit.cshtml, um sie im Visual Studio-Editor zu öffnen. Fügen Sie nach <h2>Submit</h2> die folgende Zeile hinzu. Derzeit ist ViewBag.MessageCount leer. Sie füllen diese Angabe später mit Daten auf.
```
<p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
```
Sie haben nun Ihre GUI implementiert. Drücken Sie F5 , um Ihre Anwendung auszuführen und zu prüfen, ob diese korrekt angezeigt wird.

Schreiben des Codes für die Übermittlung von Elementen an die Service Bus-Warteschlange

Sie fügen nun den Code für die Übermittlung von Elementen in die Warteschlange hinzu. Zuerst erstellen Sie die Klasse mit den Verbindungsinformationen für die Service Bus-Warteschlange. Anschließend initialisieren Sie Ihre Verbindung in „Global.aspx.cs“. Zuletzt aktualisieren Sie den zuvor in „HomeController.cs“ erstellten Übermittlungscode, um die Elemente an die Service Bus-Warteschlange zu übermitteln.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf FrontendWebRole (klicken Sie auf das Projekt, nicht auf die Rolle). Klicken Sie auf Hinzufügen und dann auf Klasse.
Geben Sie der Klasse den Namen QueueConnector.cs. Klicken Sie auf Hinzufügen, um die Klasse zu erstellen.

Sie fügen nun den Code hinzu, der Ihre Verbindungsinformationen kapselt und die Verbindung zur Service Bus-Warteschlange initialisiert. Ersetzen Sie den gesamten Inhalt von „QueueConnector.cs“ durch den folgenden Code, und geben Sie Werte für your Service Bus namespace (Ihr Namespacename) und yourKey ein. Letzterer ist der Primärschlüssel, den Sie über das Azure-Portal abgerufen haben.

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

Stellen Sie nun sicher, dass Ihre Initialize-Methode aufgerufen wird. Doppelklicken Sie im Projektmappen-Explorer auf Global.asax\Global.asax.cs.
Fügen Sie am Ende der Application_Start-Methode die folgende Codezeile hinzu.
```
 FrontendWebRole.QueueConnector.Initialize().Wait();
```
Zuletzt aktualisieren Sie den zuvor erstellten Webcode, um die Elemente an die Warteschlange zu übermitteln. Doppelklicken Sie im Projektmappen-Explorer auf Controllers\HomeController.cs.

Aktualisieren Sie die Submit()-Methode (Überladung ohne Parameter) wie folgt, um die Nachrichtenanzahl für die Warteschlange abzurufen.

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

         return View();
     }

Aktualisieren Sie die Submit(OnlineOrder order)-Methode (Überladung mit einem Parameter) wie folgt, um Bestellinformationen an die Warteschlange zu übermitteln.

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

Führen Sie die Anwendung nun erneut aus. Bei jeder Übermittlung einer Bestellung steigt der Nachrichtenzähler an.

Erstellen einer Workerrolle

Sie erstellen nun die Workerrolle zur Verarbeitung der übermittelten Nachrichten. In diesem Beispiel wird die Visual Studio-Projektvorlage Workerrolle mit Service Bus-Warteschlange verwendet. Sie haben die erforderlichen Anmeldeinformationen bereits aus dem Portal abgerufen.

Stellen Sie sicher, dass Sie Visual Studio mit Ihrem Azure-Konto verbunden haben.
Klicken Sie in Visual Studio im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Rollen im Projekt MultiTierApp.
Wählen Sie Hinzufügen und dann Neues Workerrollenprojekt aus. Das Dialogfeld Neues Rollenprojekt hinzufügen wird geöffnet.
Wählen Sie im Dialogfeld Neues Rollenprojekt hinzufügen die Option Workerrolle aus. Wählen Sie nicht Workerrolle mit Service Bus-Warteschlange aus, da damit Code generiert wird, der das Legacy-SDK von Service Bus verwendet.
Geben Sie im dem Projekt im Feld Name den Namen OrderProcessingRole. Wählen Sie anschließend Hinzufügen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt OrderProcessingRole, und wählen Sie NuGet-Pakete verwalten aus.
Wählen Sie die Registerkarte Durchsuchen aus, und suchen Sie nach Azure.Messaging.ServiceBus. Wählen Sie das Paket Azure.Messaging.ServiceBus und dann Installieren aus, und akzeptieren Sie die Nutzungsbedingungen.
Führen Sie die gleichen Schritte aus, um dem Projekt das NuGet-Paket Azure.Identity hinzuzufügen.
Erstellen Sie die OnlineOrder-Klasse, um die Nachrichten abzubilden, während diese aus der Warteschlange verarbeitet werden. Sie können dabei eine zuvor erstellte Klasse wiederverwenden. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die OrderProcessingRole-Klasse (Rechtsklick auf die Klasse, nicht die Rolle). Wählen Sie Hinzufügen und dann Vorhandenes Element aus.
Durchsuchen Sie den Unterordner nach FrontendWebRole\Models, und doppelklicken Sie dann auf OnlineOrder.cs, um die Klasse dem Projekt hinzuzufügen.

Fügen Sie in der Datei WorkerRole.cs im Projekt OrderProcessingRole die folgende using-Anweisung hinzu.

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

Fügen Sie in WorkerRole.cs die folgenden Eigenschaften hinzu.

Wichtig

Verwenden Sie die Verbindungszeichenfolge für den Namespace, den Sie sich als Teil der Voraussetzungen notiert haben.

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

Aktualisieren Sie die OnStart-Methode, um ein ServiceBusClient-Objekt und dann ein ServiceBusReceiver-Objekt zum Empfangen von Nachrichten von OrdersQueue zu erstellen.

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

Aktualisieren Sie die RunAsync-Methode so, dass sie den Code zum Empfangen von Nachrichten enthält.

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

Sie haben die Anwendung fertiggestellt. Sie können die vollständige Anwendung testen, indem Sie im Projektmappen-Explorer mit der rechten Maustaste auf das MultiTierApp-Projekt klicken und dann Set as Startup Project auswählen und F5 drücken. Die Nachrichtenzahl steigt nicht an, weil die Workerrolle die Elemente in der Warteschlange verarbeitet und als abgeschlossen markiert. Sie können die Ausgabe Ihrer Workerrolle in der Azure-Serveremulator-GUI anzeigen. Klicken Sie dazu mit der rechten Maustaste in den Infobereich Ihrer Taskleiste, und wählen Sie Serveremulator-GUI anzeigen.

Nächste Schritte

Weitere Informationen zum Servicebus finden Sie in den folgenden Ressourcen: