.NET-toepassing met meerdere lagen die Azure Service Bus-wachtrijen gebruikt

Artikel
10/18/2023

Ontwikkelen voor Microsoft Azure is eenvoudig met Visual Studio en de gratis Azure SDK voor .NET. In deze zelfstudie doorloopt u de stappen voor het maken van een toepassing die meerdere Azure-resources in uw lokale omgeving gebruikt.

U leert het volgende:

De computer met een enkele download en installatie instellen voor het ontwikkelen voor Azure.
Visual Studio gebruiken om te ontwikkelen voor Azure.
Een toepassing met meerdere lagen maken in Azure met de web- en werkrollen.
Communiceren tussen lagen met Service Bus-wachtrijen.

Notitie

U hebt een Azure-account nodig om deze zelfstudie te voltooien. U kunt uw voordelen als MSDN-abonnee activeren of u aanmelden voor een gratis account.

In deze zelfstudie bouwt en voert u de toepassing met meerdere lagen uit in een Azure-cloudservice. De front-end is een ASP.NET MVC-webrol en de back-end is een werkrol die gebruikmaakt van een Service Bus-wachtrij. U kunt dezelfde toepassing met meerdere lagen maken met de front-end als een webproject dat wordt geïmplementeerd op een Azure-website in plaats van een cloudservice. U kunt ook de zelfstudie .NET on-premises/hybride cloud-toepassing gebruiken.

In de volgende schermopname ziet u de voltooide toepassing.

Application's Submit page

Scenario-overzicht: communicatie tussen rollen

Als u een order wilt indienen voor verwerking, moet het front-end UI-onderdeel, dat wordt uitgevoerd in de webrol, communiceren met de logica van de middelste laag, die wordt uitgevoerd in de werkrol. In dit voorbeeld wordt Service Bus Messaging gebruikt voor communicatie tussen de lagen.

Met behulp van Service Bus Messaging tussen de weblaag en de middelste laag worden de twee onderdelen losgekoppeld. In tegenstelling tot directe berichten (dat wil gezegd TCP of HTTP), maakt de weblaag niet rechtstreeks verbinding met de middelste laag; In plaats daarvan worden werkeenheden, als berichten, naar Service Bus gepusht, waardoor ze betrouwbaar worden bewaard totdat de middelste laag klaar is om ze te gebruiken en te verwerken.

Service Bus biedt twee entiteiten ter ondersteuning van Brokered Messaging: wachtrijen en onderwerpen. Met wachtrijen wordt elk bericht dat naar de wachtrij wordt verzonden, verbruikt door een enkele ontvanger. Onderwerpen ondersteunen het patroon voor publiceren/abonneren waarin elk gepubliceerde bericht beschikbaar wordt gesteld aan een abonnement dat bij het onderwerp is geregistreerd. Elk abonnement onderhoudt logisch gezien zijn eigen wachtrij met berichten. Abonnementen kunnen ook worden geconfigureerd met filterregels die de set berichten die wordt doorgegeven aan de abonnementenwachtrij beperken tot berichten die overeenkomen met het filter. In het volgende voorbeeld wordt gebruikgemaakt van Service Bus-wachtrijen.

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

Dit communicatiemechanisme heeft verschillende voordelen ten opzichte van Direct Messaging:

Tijdelijke ontkoppeling. Wanneer u het asynchrone berichtenpatroon gebruikt, hoeven producenten en consumenten niet tegelijkertijd online te zijn. Service Bus slaat de berichten veilig op totdat de verbruikende partij gereed is om de berichten te ontvangen. Hierdoor kunnen de onderdelen van de gedistribueerde toepassing worden losgekoppeld - hetzij vrijwillig, bijvoorbeeld voor onderhoud, hetzij vanwege het vastlopen van een onderdeel - zonder dat dit van invloed is op het systeem als geheel. Bovendien hoeft de betreffende toepassing mogelijk alleen online te komen op bepaalde tijdstippen gedurende de dag.
Herverdeling van taken. In veel toepassingen varieert de systeembelasting gedurende de tijd, terwijl de benodigde verwerkingstijd voor elke werkeenheid doorgaans constant blijft. Door een wachtrij tussen producenten en consumenten van berichten te plaatsen, hoeft de verbruikende toepassing (de werkrol) alleen te worden ingericht voor het opvangen van een gemiddelde belasting in plaats van een piekbelasting. De lengte van de wachtrij neemt toe of af, al naargelang het binnenkomende verkeer. Dit betekent een rechtstreekse besparing op de kosten voor de benodigde infrastructuur om de toepassingsbelasting te verwerken.
Taakverdeling. Naarmate het verkeer toeneemt, kunnen meer werkprocessen worden toegevoegd om uit de wachtrij te lezen. Elk bericht worden door slechts één van de werkprocessen verwerkt. Bovendien maakt deze taakverdeling op basis van pull optimaal gebruik van de werkmachines mogelijk, zelfs als de werkmachines verschillen in verwerkingskracht, omdat ze berichten op hun eigen maximumsnelheid ophalen. Dit patroon wordt vaak aangeduid als het concurrerend consumenten-patroon.

In de volgende gedeelten wordt de code besproken waarmee deze architectuur wordt geïmplementeerd.

Vereisten

In deze zelfstudie gebruikt u Microsoft Entra-verificatie om objecten te maken en ServiceBusAdministrationClient objecten te makenServiceBusClient. U gaat deze ook gebruiken DefaultAzureCredential en gebruiken. U moet de volgende stappen uitvoeren om de toepassing lokaal in een ontwikkelomgeving te testen.

Registreer een toepassing in de Microsoft Entra-id.
Voeg de toepassing toe aan de Service Bus Data Owner rol.
Stel de AZURE-CLIENT-IDomgevingsvariabelen , AZURE-TENANT-IDAND AZURE-CLIENT-SECRET in. Zie dit artikel voor instructies.

Zie ingebouwde Azure-rollen voor Service Bus voor een lijst met ingebouwde Service Bus-rollen.

Een naamruimte maken

De eerste stap is het maken van een naamruimte en het verkrijgen van een SAS-sleutel (Shared Access Signature) voor die naamruimte. Een naamruimte biedt een toepassingsbegrenzing voor elke toepassing die toegankelijk is via Service Bus. Er wordt automatisch een SAS-sleutel gegenereerd wanneer er een naamruimte wordt gemaakt. De combinatie van naamruimte en SAS-sleutel biedt Service Bus de benodigde referenties voor het verifiëren van toegang tot een toepassing.

Een naamruimte in de Azure-portal maken

Als u Service Bus-berichtenentiteiten wilt gebruiken in Azure, moet u eerst een naamruimte maken met een naam die uniek is binnen Azure. Een naamruimte biedt een bereikcontainer voor Service Bus-resources (wachtrijen, onderwerpen, enzovoort) in uw toepassing.

Ga als volgt te werk om een naamruimte te maken:

Meld u aan bij het Azure-portaal.
Navigeer naar de pagina Alle services.
Selecteer integratie in de linkernavigatiebalk in de lijst met categorieën, beweeg de muisaanwijzer over Service Bus en selecteer + vervolgens de knop op de Service Bus-tegel.
Voer in de tag Basisinformatie van de pagina Naamruimte maken de volgende stappen uit:
1. Kies voor Abonnement een Azure-abonnement waarin u de naamruimte maakt.
2. Kies voor Resourcegroep een bestaande resourcegroep waarin de naamruimte moet worden opgenomen of maak een nieuwe resourcegroep.
3. Voer een naam in voor de naamruimte. De naamruimtenaam moet voldoen aan de volgende naamconventies:
  - De naam moet uniek zijn in Azure. In het systeem wordt onmiddellijk gecontroleerd of de naam beschikbaar is.
  - De naamlengte is ten minste 6 en maximaal 50 tekens.
  - De naam mag alleen letters, cijfers, afbreekstreepjes "-" bevatten.
  - De naam moet beginnen met een letter en eindigen op een letter of cijfer.
  - De naam eindigt niet op '-sb' of '-mgmt'.
4. Kies voor Locatie de regio waarin uw naamruimte moet worden gehost.
5. Selecteer voor de prijscategorie de prijscategorie (Basic, Standard of Premium) voor de naamruimte. Voor deze quickstart selecteert u Standard.
  
  Belangrijk
  
  Kies Standard of Premium indien u gebruik wilt maken van onderwerpen en abonnementen. Onderwerpen/abonnementen worden niet ondersteund in de prijscategorie Basic.
  
  Als u de Prijscategorie Premium hebt geselecteerd, geeft u het aantal berichteneenheden op. De Premium-prijscategorie biedt isolatie van resources op het niveau van de CPU en het geheugen, zodat elke workload geïsoleerd wordt uitgevoerd. Deze resourcecontainer wordt een Messaging-eenheid genoemd. Een Premium-naamruimte heeft ten minste één Messaging-eenheid. U kunt 1, 2, 4, 8 of 16 berichteneenheden selecteren voor elke Service Bus Premium-naamruimte. Zie Service Bus Premium Messaging voor meer informatie.
6. Selecteer Controleren en maken onderaan de pagina.
7. Controleer de instellingen op de pagina Beoordelen en maken en selecteer Maken.
Zodra de implementatie van de resource is geslaagd, selecteert u Ga naar de resource op de implementatiepagina.
U ziet de startpagina voor uw Service Bus-naamruimte.

Verbindingsreeks naar de naamruimte (Azure Portal)

Als u een nieuwe naamruimte maakt, wordt automatisch een eerste SAS-beleid (Shared Access Signature) gegenereerd met primaire en secundaire sleutels en primaire en secundaire verbindingsreeks s die elk volledige controle over alle aspecten van de naamruimte verlenen. Raadpleeg Service Bus-verificatie en -autorisatie voor meer informatie over het maken van regels met beperktere rechten voor reguliere afzenders en ontvangers.

Een client kan de verbindingsreeks gebruiken om verbinding te maken met de Service Bus-naamruimte. Voer de volgende stappen uit om de primaire verbindingsreeks voor uw naamruimte te kopiëren:

Selecteer op de pagina Service Bus-naamruimte gedeeld toegangsbeleid in het linkermenu.
Selecteer RootManageSharedAccessKey op de pagina Beleid voor gedeelde toegang.
Selecteer in het venster Beleid: RootManageSharedAccessKey de kopieerknop naast primaire Verbinding maken iontekenreeks om de verbindingsreeks naar het klembord te kopiëren voor later gebruik. Plak deze waarde in Kladblok of een andere tijdelijke locatie.

U kunt deze pagina gebruiken om de primaire sleutel, secundaire sleutel, primaire verbindingsreeks en secundaire verbindingsreeks te kopiëren.

Een webrol maken

In dit gedeelte maakt u de front-end van uw toepassing. U maakt eerst de pagina's die door uw toepassing worden weergegeven. Vervolgens voegt u code toe waarmee items worden verzonden naar een Service Bus-wachtrij en waarmee statusinformatie over de wachtrij wordt weergegeven.

Het project maken

Start Visual Studio met beheerdersbevoegdheden: klik met de rechtermuisknop op het pictogram van het Visual Studio-programma en selecteer Vervolgens Uitvoeren als administrator. De Azure Compute Emulator, die verderop in dit artikel wordt besproken, vereist dat Visual Studio wordt gestart met beheerdersbevoegdheden.

Selecteer Nieuw in het menu Bestand van Visual Studio en selecteer vervolgens Project.
Voer op de pagina Sjablonen de volgende stappen uit:
1. Selecteer C# voor programmeertaal.
2. Selecteer Cloud voor het projecttype.
3. Selecteer Azure Cloud Service.
4. Selecteer Volgende.
Noem het project MultiTierApp, selecteer de locatie voor het project en selecteer vervolgens Maken.
Dubbelklik op de pagina Rollen op ASP.NET webrol en selecteer OK.
Beweeg de muisaanwijzer over WebRole1 onder de Azure Cloud Service-oplossing, selecteer het potloodpictogram en wijzig de naam van de webrol in FrontendWebRole. Selecteer vervolgens OK. (Zorg ervoor dat u 'Frontend' invoert met een kleine letter 'e', dus niet 'FrontEnd'.)
Selecteer MVC in het dialoogvenster Een nieuwe ASP.NET-webtoepassing maken en selecteer vervolgens Maken.
Klik in Solution Explorer in het project FrontendWebRole met de rechtermuisknop op Verwijzingen en selecteer NuGet-pakketten beheren.
Selecteer het tabblad Bladeren en zoek vervolgens naar Azure.Messaging.ServiceBus. Selecteer het pakket Azure.Messaging.ServiceBus , selecteer Installeren en accepteer de gebruiksvoorwaarden.

Na de installatie wordt verwezen naar de vereiste clientassembly's en zijn enkele nieuwe codebestanden toegevoegd.
Volg dezelfde stappen om het Azure.Identity NuGet-pakket toe te voegen aan het project.
Vouw FronendWebRole uit in Solution Explorer, klik met de rechtermuisknop op Modellen en selecteer Toevoegen en selecteer Vervolgens Klasse. Typ in het vak Naam de naam OnlineOrder.cs. Selecteer vervolgens Toevoegen.

De code voor de webrol schrijven

In dit gedeelte maakt u de verschillende pagina's die door uw toepassing worden weergegeven.

In het bestand OnlineOrder.cs in Visual Studio vervangt u de bestaande naamruimtedefinitie door de volgende code:

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

Dubbelklik in Solution Explorer op Controllers\HomeController.cs. Voeg de volgende using-instructies aan het begin van het bestand toe om de naamruimten op te nemen voor het model dat u zojuist hebt gemaakt, maar ook voor Service Bus.
```
 using FrontendWebRole.Models;
 using Azure.Messaging.ServiceBus;    
```

In het bestand HomeController.cs in Visual Studio vervangt u bovendien de bestaande naamruimtedefinitie door de volgende code. Deze code bevat methoden voor het afhandelen van de verzending van items naar de wachtrij.

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

Selecteer Build Solution in het menu Build om de nauwkeurigheid van uw werk tot nu toe te testen.
Maak nu de weergave voor de methode voor Submit() die u eerder hebt gemaakt. Klik met de rechtermuisknop in de Submit() methode (de overbelasting van Submit() de methode waarvoor geen parameters nodig zijn) in het HomeController.cs-bestand en kies Vervolgens Weergave toevoegen.
Selecteer Toevoegen in het dialoogvenster Nieuw item toevoegen.
Voer in het dialoogvenster Weergave toevoegen de volgende stappen uit:
1. Kies Maken in de lijst Sjabloon.
2. Selecteer in de lijst Modelklasse de klasse OnlineOrder.
3. Selecteer Toevoegen.
Wijzig nu de weergegeven naam van uw toepassing. Dubbelklik in Solution Explorer op het bestand Views\Shared\_Layout.cshtml om het te openen in de Visual Studio-editor.
Vervang alle instanties van Mijn ASP.NET-toepassing door Producten van Northwind Traders.
Verwijder de koppelingen Start, Info en Contact. Verwijder de gemarkeerde code:
Wijzig tot slot de verzendpagina om enige informatie over de wachtrij op te nemen. Dubbelklik in Solution Explorer op het bestand Views\Home\Submit.cshtml om dit te openen in de Visual Studio-editor. Voeg de volgende regel toe na <h2>Submit</h2>. Op dit moment is ViewBag.MessageCount leeg. U vult deze later in.
```
<p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
```
U hebt nu de gebruikersinterface geïmplementeerd. Druk op F5 om uw toepassing uit te voeren en te controleren of deze voldoet aan uw verwachting.

De code schrijven voor het indienen van items aan een Service Bus-wachtrij

Voeg nu code toe voor het indienen van items aan een wachtrij. U maakt eerst een klasse die de verbindingsgegevens van de Service Bus-wachtrij bevat. Vervolgens initialiseert u de verbinding vanuit Global.aspx.cs. Tot slot werkt u de verzendcode bij die u eerder hebt gemaakt in HomeController.cs, zodat items daadwerkelijk naar een Service Bus-wachtrij worden verzonden.

Klik in Solution Explorer met de rechtermuisknop op FrontendWebRole (klik met de rechtermuisknop op het project, niet op de rol). Selecteer Toevoegen en selecteer vervolgens Klasse.
Geef de klasse de naam QueueConnector.cs. Selecteer Toevoegen om de klasse te maken.

Voeg nu code toe waarin de verbindingsgegevens zijn opgenomen en waarmee de verbinding met een Service Bus-wachtrij wordt geïnitialiseerd. Vervang de volledige inhoud van QueueConnector.cs door de volgende code en voer waarden in voor your Service Bus namespace (de naam van uw naamruimte) en yourKey. Dit is de primaire sleutel die u eerder van Azure Portal hebt gekregen.

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

Controleer nu of uw methode voor Initialiseren wordt aangeroepen. Dubbelklik in Solution Explorer op Global.asax\Global.asax.cs.
Voeg de volgende coderegel toe aan het einde van de methode Application_Start.
```
 FrontendWebRole.QueueConnector.Initialize().Wait();
```
Werk tot slot de webcode die u eerder hebt gemaakt, bij om items naar de wachtrij te verzenden. Dubbelklik in Solution Explorer op Controllers\HomeController.cs.

Werk de methode Submit() (de overbelasting waarvoor geen parameters zijn vereist) als volgt bij om het aantal berichten voor de wachtrij te verkrijgen.

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

         return View();
     }

Werk de methode Submit(OnlineOrder order) (de overbelasting waarvoor één parameter moet worden gebruikt) als volgt bij om ordergegevens naar de wachtrij te verzenden.

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

U kunt nu de toepassing opnieuw uitvoeren. Het aantal berichten neemt toe elke keer wanneer u een order verzendt.

De werkrol maken

U gaat nu de werkrol maken waarmee de orderinzendingen worden verwerkt. In dit voorbeeld wordt de Visual Studio-projectsjabloon Werkrol met Service Bus-wachtrij gebruikt. U hebt al de vereiste referenties ontvangen van de portal.

Zorg ervoor dat u Visual Studio aan uw Azure-account hebt gekoppeld.
Klik in Visual Studio in Solution Explorer met de rechtermuisknop op de map Rollen onder het MultiTierApp-project.
Selecteer Toevoegen en selecteer vervolgens Nieuw werkrolproject. Het dialoogvenster Nieuw rolproject toevoegen wordt weergegeven.
Selecteer Werkrol in het dialoogvenster Nieuw rolproject toevoegen. Selecteer geen werkrol met Service Bus-wachtrij omdat er code wordt gegenereerd die gebruikmaakt van de verouderde Service Bus SDK.
Voer in het vak Naam de naam OrderProcessingRole voor het project in. Selecteer vervolgens Toevoegen.
Klik in Solution Explorer met de rechtermuisknop op het project OrderProcessingRole en selecteer NuGet-pakketten beheren.
Selecteer het tabblad Bladeren en zoek vervolgens naar Azure.Messaging.ServiceBus. Selecteer het pakket Azure.Messaging.ServiceBus , selecteer Installeren en accepteer de gebruiksvoorwaarden.
Volg dezelfde stappen om het Azure.Identity NuGet-pakket toe te voegen aan het project.
Maak een klasse OnlineOrder die de orders vertegenwoordigt tijdens het verwerken van de wachtrij. U kunt een klasse die u al hebt gemaakt opnieuw gebruiken. Klik in Solution Explorer met de rechtermuisknop op de klasse OrderProcessingRole (klik met de rechtermuisknop op het klassepictogram en niet op de rol). Selecteer Toevoegen en selecteer vervolgens Bestaand item.
Blader naar de submap voor FrontendWebRole\Models en dubbelklik vervolgens op OnlineOrder.cs om het bestand toe te voegen aan dit project.

Voeg de volgende using instructie toe aan het bestand WorkerRole.cs in het project OrderProcessingRole .

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

Voeg in WorkerRole.cs de volgende eigenschappen toe.

Belangrijk

Gebruik de verbindingsreeks voor de naamruimte die u hebt genoteerd als onderdeel van de vereisten.

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

Werk de OnStart methode bij om een ServiceBusClient object te maken en vervolgens een ServiceBusReceiver object te ontvangen van de 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);
        }
    }

Werk de RunAsync methode bij om de code op te nemen voor het ontvangen van berichten.

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

U hebt de toepassing voltooid. U kunt de volledige toepassing testen door met de rechtermuisknop te klikken op het MultiTierApp-project in Solution Explorer, Instellen als opstartproject te selecteren en vervolgens op F5 te drukken. Het aantal berichten wordt niet verhoogd, omdat de werkrol items uit de wachtrij verwerkt en deze als voltooid markeert. U ziet de trace-uitvoer van uw werkrol door de gebruikersinterface van de Azure-rekenemulator weer te geven. Klik hiervoor met de rechtermuisknop op het emulatorpictogram in het systeemvak van de taakbalk en selecteer Gebruikersinterface van de rekenemulator weergeven.

Volgende stappen

Zie de volgende resources voor meer informatie over Service Bus: