Aan de slag met Azure Service Bus en abonnementen (.NET)

Artikel
12/01/2021
15 minuten om te lezen

In deze quickstart ziet u hoe u berichten verzendt naar een Service Bus-onderwerp en berichten ontvangt van een abonnement op dat onderwerp met behulp van de Azure.Messaging.ServiceBus .NET-bibliotheek.

In deze quickstart gaat u de volgende stappen volgen:

Een Service Bus-naamruimte maken met de Azure-portal.
Een Service Bus-onderwerp maken met de Azure-portal.
Een Service Bus-abonnement maken met de Azure-portal.
Schrijf een .NET Core-consoletoepassing om een set berichten naar het onderwerp te verzenden.
Schrijf een .NET Core-consoletoepassing om deze berichten van het abonnement te ontvangen.

Notitie

Deze quickstart bevat stapsgewijs instructies voor het implementeren van een eenvoudig scenario voor het verzenden van een batch berichten naar een Service Bus-onderwerp en het ontvangen van die berichten van een abonnement van het onderwerp. Zie .NET-voorbeelden op Service Bus voor meer voorbeelden over andere en geavanceerde scenario GitHub.

Vereisten

Als u de service nog niet eerder hebt gemaakt, Service Bus overzicht voordat u deze quickstart gaat doen.

Azure-abonnement. Als u Azure-services wilt gebruiken, Service Bus Azure-services, hebt u een abonnement nodig. Als u nog geen Azure-account hebt, kunt u zich aanmelden voor een gratis proefversie of uw voordelen als MSDN-abonnee gebruiken wanneer u een account maakt.
Microsoft Visual Studio 2019. De Azure Service Bus-clientbibliotheek maakt gebruik van nieuwe functies die zijn geïntroduceerd in C# 8.0. U kunt de bibliotheek nog steeds gebruiken met eerdere versies van C#, maar de nieuwe syntaxis is dan niet beschikbaar. Als u gebruik wilt maken van de volledige syntaxis, raden we u aan om te compileren met de .NET Core SDK 3.0 of hoger en de taalversie in te stellen op latest . Als u Visual Studio gebruikt, weet dan dat de versies vóór Visual Studio 2019 niet compatibel met de hulpprogramma's die nodig zijn om C# 8.0 projecten te bouwen. Visual Studio 2019, met inbegrip van de gratis Community-editie, hier worden gedownload.

Een naamruimte in 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 scoping container voor het verwerken van Service Bus-resources in uw toepassing.

Ga als volgt te werk om een naamruimte te maken:

Meld u aan bij Azure Portal
Klik in het linkernavigatievenster van de portal achtereenvolgens op + Een resource maken, Integratie en Service Bus.
Volg deze stappen in de tag Basisbeginselen van de pagina Naamruimte maken:
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. In het systeem wordt onmiddellijk gecontroleerd of de naam beschikbaar is. Raadpleeg Create Namespace (Naamruimte maken) voor een lijst met regels voor het benoemen van naamruimtes.
4. Kies voor Locatie de regio waarin uw naamruimte moet worden gehost.
5. Selecteer bij Prijscategorie de prijscategorie (Basic, Standard of Premium) voor de naamruimte. Voor deze snelstart selecteert u Standaard.
  
  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, 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 voor elke Service Bus Premium-naamruimte 1, 2 of 4 Messaging-eenheden selecteren. Zie Service Bus Premium Messaging voor meer informatie.
6. Selecteer Controleren + maken. Uw naamruimte wordt nu gemaakt en ingeschakeld. U moet wellicht enkele minuten wachten terwijl de resources voor uw account worden ingericht.
7. Controleer de instellingen op de pagina Beoordelen en maken en selecteer Maken.
Selecteer Ga naar resource op de implementatiepagina.
U ziet de startpagina voor uw Service Bus-naamruimte.

De verbindingsreeks ophalen

Het maken van een nieuwe naamruimte genereert automatisch een eerste Shared Access Signature-beleid (SAS) met primaire en secundaire sleutels en primaire en secundaire verbindingsreeksen 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.

Als u de primaire connection string voor uw naamruimte wilt kopiëren, volgt u deze stappen:

Selecteer op Service Bus pagina Naamruimte de optie Beleid voor gedeelde toegang in het menu links.
Selecteer op de pagina Beleid voor gedeelde toegang de optie RootManageSharedAccessKey.
Klik in het venster Beleid: RootManageSharedAccessKey op de knop Kopiëren naast Primaire verbindingsreeks 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 en secundaire sleutel te connection string.

Een onderwerp maken met de Azure-portal

Selecteer in het linkermenu op de pagina Service Bus-naamruimte de optie Onderwerpen.
Selecteer + Onderwerp op de werkbalk.
Voer een naam in voor het onderwerp. Houd voor de overige opties de standaardwaarden aan.
Selecteer Maken.

Een abonnement op het onderwerp maken

Selecteer het onderwerp dat u in de vorige sectie hebt gemaakt.
Selecteer op Service Bus pagina Onderwerp + Abonnement op de werkbalk.
Volg deze stappen op de pagina Abonnement maken:
1. Voer S1 in als naam van het abonnement.
2. Voer 3 in bij Maximum aantal leveringen.
3. Selecteer vervolgens Maken om het abonnement te maken.

Belangrijk

Noteer de connection string naamruimte, de onderwerpnaam en de naam van het abonnement. U gebruikt deze later in deze zelfstudie.

Berichten naar het onderwerp verzenden

In deze sectie ziet u hoe u een .NET Core-consoletoepassing maakt om berichten naar een Service Bus verzenden.

Notitie

Een consoletoepassing maken

Start Visual Studio 2019.
Selecteer Een nieuw project maken.
Voer in het dialoogvenster Een nieuw project maken de volgende stappen uit: Als dit dialoogvenster niet wordt weergegeven, selecteert u in het menu Bestand, Nieuw en vervolgens Project.
1. Selecteer de programmeertaal C# .
2. Selecteer Console als het type toepassing.
3. Selecteer Consoletoepassing in de lijst met resultaten.
4. Selecteer vervolgens Volgende.
Voer TopicSender in als projectnaam, ServiceBusTopicQuickStart als naam van de oplossing en selecteer volgende.
Selecteer op de pagina Aanvullende informatie Maken om de oplossing en het project te maken.

Het Service Bus NuGet-pakket toevoegen

Selecteer Tools > NuGet-pakketbeheer > Package Manager Console in het menu.
Voer de volgende opdracht uit om het NuGet-pakket Azure.Messaging.ServiceBus te installeren:
```
Install-Package Azure.Messaging.ServiceBus
```

Code toevoegen om berichten naar het onderwerp te verzenden

Voeg in Program.cs de volgende instructies toe boven aan de naamruimtedefinitie, using vóór de klassedeclaratie.
```
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;
```

Declareer Program binnen de klasse de volgende eigenschappen, net vóór de methode Main . Vervang <NAMESPACE CONNECTION STRING> door de verbindingstekenreeks voor uw Service Bus-naamruimte. Vervang door <TOPIC NAME> de naam van uw Service Bus onderwerp.

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

// name of your Service Bus topic
static string topicName = "<TOPIC NAME>";

// the client that owns the connection and can be used to create senders and receivers
static ServiceBusClient client;

// the sender used to publish messages to the topic
static ServiceBusSender sender;

// number of messages to be sent to the topic
private const int numOfMessages = 3;

Vervang code in Program.cs door de volgende code. Hier volgen de belangrijke stappen uit de code.

Hiermee maakt u een ServiceBusClient-object met behulp van de connection string naar de naamruimte.
Roept de methode CreateSender aan voor het object om een ServiceBusClient ServiceBusSender-object te maken voor het specifieke Service Bus onderwerp.
Hiermee maakt u een ServiceBusMessageBatch-object met behulp van serviceBusSender.CreateMessageBatchAsync.
Voeg berichten toe aan de batch met behulp van de ServiceBusMessageBatch.TryAddMessage.
Hiermee wordt de batch berichten naar het Service Bus verzonden met behulp van de methode ServiceBusSender.SendMessagesAsync.

static async Task Main()
{
    // The Service Bus client types are safe to cache and use as a singleton for the lifetime
    // of the application, which is best practice when messages are being published or read
    // regularly.
    //
    // Create the clients that we'll use for sending and processing messages.
    client = new ServiceBusClient(connectionString);
    sender = client.CreateSender(topicName);

    // create a batch 
    using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();

    for (int i = 1; i <= numOfMessages; i++)
    {
        // try adding a message to the batch
        if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
        {
            // if it is too large for the batch
            throw new Exception($"The message {i} is too large to fit in the batch.");
        }
    }

    try
    {
        // Use the producer client to send the batch of messages to the Service Bus topic
        await sender.SendMessagesAsync(messageBatch);
        Console.WriteLine($"A batch of {numOfMessages} messages has been published to the topic.");
    }
    finally
    {
        // Calling DisposeAsync on client types is required to ensure that network
        // resources and other unmanaged objects are properly cleaned up.
        await sender.DisposeAsync();
        await client.DisposeAsync();
    }

    Console.WriteLine("Press any key to end the application");
    Console.ReadKey();
}

Het bestand Program.cs moet er als volgende uitzien:

Zie opmerkingen bij de code voor meer informatie.

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

namespace TopicSender
{
    class Program
    {
        // connection string to your Service Bus namespace
        static string connectionString = "<NAMESPACE CONNECTION STRING>";

        // name of your Service Bus topic
        static string topicName = "<TOPIC NAME>";

        // the client that owns the connection and can be used to create senders and receivers
        static ServiceBusClient client;

        // the sender used to publish messages to the topic
        static ServiceBusSender sender;

        // number of messages to be sent to the topic
        private const int numOfMessages = 3;

        static async Task Main()
        {
            // The Service Bus client types are safe to cache and use as a singleton for the lifetime
            // of the application, which is best practice when messages are being published or read
            // regularly.
            //
            // Create the clients that we'll use for sending and processing messages.
            client = new ServiceBusClient(connectionString);
            sender = client.CreateSender(topicName);

            // create a batch 
            using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();

            for (int i = 1; i <= numOfMessages; i++)
            {
                // try adding a message to the batch
                if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
                {
                    // if it is too large for the batch
                    throw new Exception($"The message {i} is too large to fit in the batch.");
                }
            }

            try
            {
                // Use the producer client to send the batch of messages to the Service Bus topic
                await sender.SendMessagesAsync(messageBatch);
                Console.WriteLine($"A batch of {numOfMessages} messages has been published to the topic.");
            }
            finally
            {
                // Calling DisposeAsync on client types is required to ensure that network
                // resources and other unmanaged objects are properly cleaned up.
                await sender.DisposeAsync();
                await client.DisposeAsync();
            }

            Console.WriteLine("Press any key to end the application");
            Console.ReadKey();
        }
    }
}

Vervang <NAMESPACE CONNECTION STRING> door de verbindingstekenreeks voor uw Service Bus-naamruimte. Vervang door <TOPIC NAME> de naam van uw Service Bus onderwerp.
Bouw het project en controleer of er geen fouten zijn.
Voer het programma uit en wacht op het bevestigingsbericht.
```
A batch of 3 messages has been published to the topic
```
Volg deze stappen in Azure Portal:
1. Navigeer naar uw Service Bus-naamruimte.
2. Ga op de pagina Overzicht, in het deelvenster midden onder, naar het tabblad Onderwerpen en selecteer het Service Bus-onderwerp. In het volgende voorbeeld is dat mytopic.
3. Op de Service Bus onderwerp ziet u in de grafiek Berichten in de onderste sectie Metrische gegevens dat er drie inkomende berichten voor het onderwerp zijn. Als u de waarde niet ziet, wacht u een paar minuten en vernieuwt u de pagina om de bijgewerkte grafiek weer te geven.
4. Selecteer het abonnement in het onderste deelvenster. In het volgende voorbeeld is dat S1. Op de Service Bus abonnement ziet u dat het aantal actieve berichten 3 is. Het abonnement heeft de drie berichten ontvangen die u naar het onderwerp hebt verzonden, maar er is nog geen ontvanger die ze heeft opgehaald.

Berichten van een abonnement ontvangen

In deze sectie maakt u een .NET Core-consoletoepassing die berichten ontvangt van het abonnement naar het Service Bus onderwerp.

Notitie

Een project maken voor de ontvanger

Klik in Solution Explorer venster met de rechtermuisknop op de oplossing ServiceBusTopicQuickStart, wijs Toevoegen aan en selecteer Nieuw Project.
Selecteer Consoletoepassing en selecteer Volgende.
Voer SubscriptionReceiver in als Project naam en selecteer Volgende.
Selecteer maken op de pagina Aanvullende informatie.
Klik in Solution Explorer venster met de rechtermuisknop op SubscriptionReceiver en selecteer Set as a Startup Project.

Het Service Bus NuGet-pakket toevoegen

Selecteer Tools > NuGet-pakketbeheer > Package Manager Console in het menu.
Controleer in Pakketbeheer Console of SubscriptionReceiver is geselecteerd voor het standaardproject. Als dat niet het beste is, gebruikt u de vervolgkeuzelijst om SubscriptionReceiver te selecteren.
Voer de volgende opdracht uit om het NuGet-pakket Azure.Messaging.ServiceBus te installeren:
```
Install-Package Azure.Messaging.ServiceBus
```

Code toevoegen om berichten van het abonnement te ontvangen

Voeg in Program.cs de volgende instructies toe boven aan de naamruimtedefinitie, using vóór de klassedeclaratie.
```
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;
```

Declareer Program binnen de klasse de volgende eigenschappen, net vóór de methode Main . Vervang de tijdelijke aanduidingen door de juiste waarden:

<NAMESPACE CONNECTION STRING> door de verbindingsreeks voor uw Service Bus-naamruimte
<TOPIC NAME>door de naam van uw Service Bus onderwerp
<SERVICE BUS - TOPIC SUBSCRIPTION NAME> door de naam van het abonnement op het onderwerp.

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

// name of the Service Bus topic
static string topicName = "<SERVICE BUS TOPIC NAME>";

// name of the subscription to the topic
static string subscriptionName = "<SERVICE BUS - TOPIC SUBSCRIPTION NAME>";

// the client that owns the connection and can be used to create senders and receivers
static ServiceBusClient client;

// the processor that reads and processes messages from the subscription
static ServiceBusProcessor processor;

Voeg de volgende methoden toe aan de Program klasse om ontvangen berichten en eventuele fouten af te handelen.

// handle received messages
static async Task MessageHandler(ProcessMessageEventArgs args)
{
    string body = args.Message.Body.ToString();
    Console.WriteLine($"Received: {body} from subscription: {subscriptionName}");

    // complete the message. messages is deleted from the subscription. 
    await args.CompleteMessageAsync(args.Message);
}

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

Vervang code in Program.cs door de volgende code. Hier volgen de belangrijke stappen uit de code:

Hiermee maakt u een ServiceBusClient-object met behulp van de connection string naar de naamruimte.
Roept de methode CreateProcessor aan voor het object om een ServiceBusClient ServiceBusProcessor-object te maken voor de opgegeven Service Bus wachtrij.
Hiermee geeft u handlers op voor de processMessageAsync- en ProcessErrorAsync-gebeurtenissen van het ServiceBusProcessor object.
Begint met het verwerken van berichten door StartProcessingAsync voor het object aan ServiceBusProcessor teroepen.
Wanneer de gebruiker op een toets drukt om de verwerking te beëindigen, roept de StopProcessingAsync op het ServiceBusProcessor object aan.

Zie opmerkingen bij de code voor meer informatie.

static async Task Main()
{
    // The Service Bus client types are safe to cache and use as a singleton for the lifetime
    // of the application, which is best practice when messages are being published or read
    // regularly.
    //
    // Create the clients that we'll use for sending and processing messages.
    client = new ServiceBusClient(connectionString);

    // create a processor that we can use to process the messages
    processor = client.CreateProcessor(topicName, subscriptionName, new ServiceBusProcessorOptions());

    try
    {
        // add handler to process messages
        processor.ProcessMessageAsync += MessageHandler;

        // add handler to process any errors
        processor.ProcessErrorAsync += ErrorHandler;

        // start processing 
        await processor.StartProcessingAsync();

        Console.WriteLine("Wait for a minute and then press any key to end the processing");
        Console.ReadKey();

        // stop processing 
        Console.WriteLine("\nStopping the receiver...");
        await processor.StopProcessingAsync();
        Console.WriteLine("Stopped receiving messages");
    }
    finally
    {
        // Calling DisposeAsync on client types is required to ensure that network
        // resources and other unmanaged objects are properly cleaned up.
        await processor.DisposeAsync();
        await client.DisposeAsync();
    }
}

Zo zou uw Program.cs eruit moeten zien:

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

namespace SubscriptionReceiver
{
    class Program
    {
        // connection string to your Service Bus namespace
        static string connectionString = "<NAMESPACE CONNECTION STRING>";

        // name of the Service Bus topic
        static string topicName = "<SERVICE BUS TOPIC NAME>";

        // name of the subscription to the topic
        static string subscriptionName = "<SERVICE BUS - TOPIC SUBSCRIPTION NAME>";

        // the client that owns the connection and can be used to create senders and receivers
        static ServiceBusClient client;

        // the processor that reads and processes messages from the subscription
        static ServiceBusProcessor processor;

        // handle received messages
        static async Task MessageHandler(ProcessMessageEventArgs args)
        {
            string body = args.Message.Body.ToString();
            Console.WriteLine($"Received: {body} from subscription: {subscriptionName}");

            // complete the message. messages is deleted from the subscription. 
            await args.CompleteMessageAsync(args.Message);
        }

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

        static async Task Main()
        {
            // The Service Bus client types are safe to cache and use as a singleton for the lifetime
            // of the application, which is best practice when messages are being published or read
            // regularly.
            //
            // Create the clients that we'll use for sending and processing messages.
            client = new ServiceBusClient(connectionString);

            // create a processor that we can use to process the messages
            processor = client.CreateProcessor(topicName, subscriptionName, new ServiceBusProcessorOptions());

            try
            {
                // add handler to process messages
                processor.ProcessMessageAsync += MessageHandler;

                // add handler to process any errors
                processor.ProcessErrorAsync += ErrorHandler;

                // start processing 
                await processor.StartProcessingAsync();

                Console.WriteLine("Wait for a minute and then press any key to end the processing");
                Console.ReadKey();

                // stop processing 
                Console.WriteLine("\nStopping the receiver...");
                await processor.StopProcessingAsync();
                Console.WriteLine("Stopped receiving messages");
            }
            finally
            {
                // Calling DisposeAsync on client types is required to ensure that network
                // resources and other unmanaged objects are properly cleaned up.
                await processor.DisposeAsync();
                await client.DisposeAsync();
            }
        }
    }
}

Vervang de tijdelijke aanduidingen door de juiste waarden:
- <NAMESPACE CONNECTION STRING> door de verbindingsreeks voor uw Service Bus-naamruimte
- <TOPIC NAME>door de naam van uw Service Bus onderwerp
- <SERVICE BUS - TOPIC SUBSCRIPTION NAME> door de naam van het abonnement op het onderwerp.
Bouw het project en controleer of er geen fouten zijn.

Voer de ontvangende toepassing uit. Als het goed is, ziet u de ontvangen berichten. Druk op een toets om de ontvanger en de toepassing te stoppen.

Wait for a minute and then press any key to end the processing
Received: Message 1 from subscription: S1
Received: Message 2 from subscription: S1
Received: Message 3 from subscription: S1

Stopping the receiver...
Stopped receiving messages

Controleer de portal opnieuw.
- Op de Service Bus onderwerp ziet u in de grafiek Berichten drie inkomende berichten en drie uitgaande berichten. Als u deze aantallen niet ziet, wacht u een paar minuten en vernieuwt u de pagina om de bijgewerkte grafiek weer te geven.
- Op de pagina Service Bus-abonnement ziet u dat het Aantal actieve berichten nul is. Dat komt omdat een ontvanger berichten van dit abonnement heeft ontvangen en de berichten heeft voltooid.

Volgende stappen

Raadpleeg de volgende documentatie en voorbeelden:

Aan de slag met Azure Service Bus en abonnementen (.NET)

Beoordeel uw ervaring

Vereisten

Een naamruimte in Azure Portal maken

De verbindingsreeks ophalen

Een onderwerp maken met de Azure-portal

Een abonnement op het onderwerp maken

Berichten naar het onderwerp verzenden

Een consoletoepassing maken

Het Service Bus NuGet-pakket toevoegen

Code toevoegen om berichten naar het onderwerp te verzenden

Berichten van een abonnement ontvangen

Een project maken voor de ontvanger

Het Service Bus NuGet-pakket toevoegen

Code toevoegen om berichten van het abonnement te ontvangen

Volgende stappen