Kom igång med Azure Service Bus ämnen och prenumerationer (.NET)

Artikel
12/01/2021
14 minuter för att läsa

Den här snabbstarten visar hur du skickar meddelanden till ett Service Bus-ämne och tar emot meddelanden från en prenumeration på ämnet med hjälp av .NET-biblioteket Azure.Messaging.ServiceBus.

I den här snabbstarten gör du följande:

Skapa ett Service Bus-namnområde med Azure Portal.
Skapa ett Service Bus-ämne med Azure Portal.
Skapa en Service Bus-prenumeration på ämnet med Azure Portal.
Skriva ett .NET Core-konsolprogram för att skicka en uppsättning meddelanden till ämnet.
Skriva ett .NET Core-konsolprogram för att ta emot meddelanden från prenumerationen.

Anteckning

Den här snabbstarten innehåller stegvisa instruktioner för att implementera ett enkelt scenario för att skicka en batch med meddelanden till ett Service Bus-ämne och ta emot dessa meddelanden från en prenumeration på ämnet. Fler exempel på andra och avancerade scenarier finns i Service Bus .NET-exempel på GitHub.

Förutsättningar

Om du inte har börjat använda tjänsten kan du Service Bus översikt innan du gör den här snabbstarten.

Azure-prenumeration. Om du vill använda Azure-tjänster, Service Bus Azure-tjänster, behöver du en prenumeration. Om du inte har ett befintligt Azure-konto kan du registrera dig för en kostnadsfri utvärderingsversion eller använda dina MSDN-prenumerantförmåner när du skapar ett konto.
Microsoft Visual Studio 2019. Azure Service Bus-klientbiblioteket använder nya funktioner som introducerades i C# 8.0. Du kan fortfarande använda biblioteket med tidigare C#-språkversioner, men den nya syntaxen är inte tillgänglig. Om du vill använda den fullständiga syntaxen rekommenderar vi att du kompilerar med .NET Core SDK 3.0 eller senare och språkversionen inställd på latest . Om du använder Visual Studio är versioner före Visual Studio 2019 inte kompatibla med de verktyg som behövs för att skapa C# 8.0-projekt. Visual Studio 2019, inklusive den kostnadsfria Community Edition, kan laddas ned här.

Skapa ett namnområde i Azure Portal

För att komma igång med Service Bus-meddelandeentiteter i Azure måste du först skapa ett namnområde med ett namn som är unikt i Azure. Ett namnområde innehåller en omfattningscontainer för adressering av Service Bus-resurser i ditt program.

Så här skapar du ett namnområde:

Logga in på Azure-portalen
I det vänstra navigeringsfältet i portalen väljer du + Skapa en resurs följt av Integration och sedan Service Bus.
I taggen Grundläggande på sidan Skapa namnområde följer du dessa steg:
1. För Prenumeration väljer du en Azure-prenumeration där du ska skapa namnrymden.
2. För Resursgrupp väljer du en befintlig resursgrupp där namnrymden ska finnas, eller så skapar du en ny.
3. Ange ett namn för namnrymden. Systemet kontrollerar omedelbart om namnet är tillgängligt. En lista över regler för namngivning av namnområden finns i Skapa namnområde REST API.
4. För Plats väljer du land eller region där namnrymden ska finnas.
5. För Prisnivå väljer du prisnivån (Basic, Standard eller Premium) för namnområdet. För den här snabbstarten väljer du Standard.
  
  Om du vill använda ämnen och prenumerationer väljer du antingen Standard eller Premium. Ämnen/prenumerationer stöds inte på prisnivån Basic.
  
  Om du har Premium på prisnivån anger du antalet meddelandeenheter. Premium-nivån ger resursisolering på processor- och minnesnivå så att varje arbetsbelastning körs självständigt. Den här resurscontainern kallas för en meddelandefunktionsenhet. Ett Premium-namnområde har minst en meddelandefunktionsenhet. Du kan välja 1, 2 eller 4 meddelandefunktionsenheter för varje Service Bus Premium-namnrymd. Mer information finns i Service Bus Premium-meddelanden.
6. Välj Granska + skapa. Systemet skapar namnområdet och aktiverar det. Du kan behöva vänta några minuter medan systemet tilldelar resurser till ditt konto.
7. På sidan Granska + skapa granskar du inställningarna och väljer Skapa.
Välj Gå till resurs på distributionssidan.
Startsidan för din Service Bus-namnrymd visas.

Hämta anslutningssträngen

När du skapar ett nytt namnområde genereras automatiskt en första princip för signatur för delad åtkomst (SAS) med primära och sekundära nycklar och primära och sekundära anslutningssträngar som var och en ger fullständig kontroll över alla aspekter av namnområdet. Se Service Bus – autentisering och auktorisering för mer information om hur du skapar regler med mer begränsade rättigheter för regelbundna sändare och mottagare.

Följ dessa steg om du vill kopiera den primära anslutningssträngen för namnområdet:

På Service Bus namnområde väljer du Principer för delad åtkomst på den vänstra menyn.
På sidan Principer för delad åtkomst väljer du RootManageSharedAccessKey.
I fönstret Princip: RootManageSharedAccessKey klickar du på knappen Kopiera bredvid Primär anslutningssträng för att kopiera anslutningssträngen till dina urklipp för senare användning. Klistra in det här värdet i Anteckningar eller på en tillfällig plats.

Du kan använda den här sidan för att kopiera primärnyckel, sekundär nyckel och sekundär anslutningssträng.

Skapa ett ämne med Azure Portal

På sidan Service Bus Namespace (Service Bus-namnrymd) väljer du Ämnen på den vänstra menyn.
Välj + Ämne i verktygsfältet.
Ange ett namn för ämnet. Lämna standardvärdena för de andra alternativen.
Välj Skapa.

Skapa en prenumeration på ämnet

Välj det ämne som du skapade i föregående avsnitt.
På sidan Service Bus ämne väljer du + Prenumeration i verktygsfältet.
På sidan Skapa prenumeration följer du dessa steg:
1. Ange S1 som namn på prenumerationen.
2. Ange 3 för Maximalt antal leveranser.
3. Välj sedan Skapa för att skapa prenumerationen.

Viktigt

Anteckna anslutningssträngen till namnområdet, ämnesnamnet och prenumerationsnamnet. Du kommer att använda dem senare i den här självstudien.

Skicka meddelanden till ämnet

Det här avsnittet visar hur du skapar ett .NET Core-konsolprogram för att skicka meddelanden till ett Service Bus ämne.

Anteckning

Skapa ett konsolprogram

Starta Visual Studio 2019.
Välj Skapa ett nytt projekt.
I dialogrutan Skapa ett nytt projekt gör du följande: Om du inte ser den här dialogrutan väljer du Arkiv på menyn, väljer Nytt och väljer sedan Project.
1. Välj C# som programmeringsspråk.
2. Välj Konsol som typ av program.
3. Välj Konsolprogram i resultatlistan.
4. Välj Nästa.
Ange TopicSender som projektnamn, ServiceBusTopicQuickStart som lösningsnamn och välj sedan Nästa.
På sidan Ytterligare information väljer du Skapa för att skapa lösningen och projektet.

Lägga till Service Bus-NuGet-paketet

Välj Verktyg > NuGet Package Manager Package Manager > Console på menyn.
Kör följande kommando för att installera NuGet-paketet Azure.Messaging.ServiceBus:
```
Install-Package Azure.Messaging.ServiceBus
```

Lägga till kod för att skicka meddelanden till ämnet

I Program.cs lägger du till using följande -instruktioner överst i namnområdesdefinitionen före klassdeklarationen.
```
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;
```

I Program klassen deklarerar du följande egenskaper precis före Main metoden . Ersätt <NAMESPACE CONNECTION STRING> med anslutningssträngen till Service Bus namnområdet. Och ersätt <TOPIC NAME> med namnet på ditt Service Bus ämne.

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

Ersätt koden i Program.cs med följande kod. Här är de viktiga stegen i koden.

Skapar ett ServiceBusClient-objekt med anslutningssträngen till namnområdet.
Anropar metoden CreateSender för objektet ServiceBusClient för att skapa ett ServiceBusSender-objekt för det Service Bus ämnet.
Skapar ett ServiceBusMessageBatch-objekt med hjälp av ServiceBusSender.CreateMessageBatchAsync.
Lägg till meddelanden i batchen med serviceBusMessageBatch.TryAddMessage.
Skickar batchen med meddelanden till Service Bus ämnet med hjälp av metoden 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();
}

Så här bör filen Program.cs se ut:

Mer information finns i kodkommentarer.

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

Ersätt <NAMESPACE CONNECTION STRING> med anslutningssträngen till Service Bus namnområdet. Och ersätt <TOPIC NAME> med namnet på ditt Service Bus ämne.
Skapa projektet och se till att det inte finns några fel.

Kör programmet och vänta på bekräftelsemeddelandet.

A batch of 3 messages has been published to the topic

I Azure Portal du följande steg:
1. Gå till Service Bus namnområdet.
2. På sidan Översikt i fönstret längst ned i mitten växlar du till fliken Ämnen och väljer Service Bus ämnet. I följande exempel är det mytopic .
3. På sidan Service Bus ämne, i diagrammet Meddelanden i det nedre måttavsnittet, kan du se att det finns tre inkommande meddelanden för ämnet. Om du inte ser värdet väntar du några minuter och uppdaterar sidan för att se det uppdaterade diagrammet.
4. Välj prenumerationen i det nedre fönstret. I följande exempel är det S1. På sidan Service Bus prenumeration visas antalet aktiva meddelanden som 3. Prenumerationen har tagit emot de tre meddelanden som du har skickat till ämnet, men ingen mottagare har valt dem ännu.

Ta emot meddelanden från en prenumeration

I det här avsnittet skapar du ett .NET Core-konsolprogram som tar emot meddelanden från prenumerationen till Service Bus ämnet.

Anteckning

Skapa ett projekt för mottagaren

I Solution Explorer högerklickar du på lösningen ServiceBusTopicQuickStart, pekar på Lägg till och väljer Ny Project.
Välj Konsolprogram och välj Nästa.
Ange SubscriptionReceiver som Project och välj Nästa.
På sidan Ytterligare information väljer du Skapa.
I fönstret Solution Explorer högerklickar du på SubscriptionReceiver och väljer Set as a Startup Project.

Lägga till Service Bus-NuGet-paketet

Välj Verktyg > NuGet Package Manager Package Manager > Console på menyn.
I fönstret Package Manager Console (Package Manager-konsol) bekräftar du att SubscriptionReceiver har valts för standardprojektet. Om inte använder du listrutan för att välja PrenumerationReceiver.
Kör följande kommando för att installera NuGet-paketet Azure.Messaging.ServiceBus:
```
Install-Package Azure.Messaging.ServiceBus
```

Lägga till kod för att ta emot meddelanden från prenumerationen

I Program.cs lägger du till using följande -instruktioner överst i namnområdesdefinitionen före klassdeklarationen.
```
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;
```

I Program klassen deklarerar du följande egenskaper precis före Main metoden . Ersätt platshållarna med rätt värden:

<NAMESPACE CONNECTION STRING>med anslutningssträngen till Service Bus namnområdet
<TOPIC NAME>med namnet på ditt Service Bus ämne
<SERVICE BUS - TOPIC SUBSCRIPTION NAME> med namnet på prenumerationen på ämnet.

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

Lägg till följande metoder i klassen Program för att hantera mottagna meddelanden och eventuella fel.

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

Ersätt koden i Program.cs med följande kod. Här är de viktiga stegen i koden:

Skapar ett ServiceBusClient-objekt med anslutningssträngen till namnområdet.
Anropar metoden CreateProcessor på objektet för ServiceBusClient att skapa ett ServiceBusProcessor-objekt för den angivna Service Bus kön.
Anger hanterare för processMessageAsync- och ProcessErrorAsync-händelser för ServiceBusProcessor objektet.
Börjar bearbeta meddelanden genom att använda StartProcessingAsync för ServiceBusProcessor objektet.
När användaren trycker på en nyckel för att avsluta bearbetningen anropar StopProcessingAsync för ServiceBusProcessor objektet.

Mer information finns i kodkommentarer.

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

Så här bör du Program.cs se ut:

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

Ersätt platshållarna med rätt värden:
- <NAMESPACE CONNECTION STRING>med anslutningssträngen till Service Bus namnområdet
- <TOPIC NAME>med namnet på ditt Service Bus ämne
- <SERVICE BUS - TOPIC SUBSCRIPTION NAME> med namnet på prenumerationen på ämnet.
Skapa projektet och se till att det inte finns några fel.

Kör mottagarprogrammet. Du bör se de mottagna meddelandena. Tryck på valfri tangent för att stoppa mottagaren och programmet.

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

Kontrollera portalen igen.
- På sidan Service Bus visas tre inkommande meddelanden och tre utgående meddelanden i diagrammet Meddelanden. Om du inte ser de här siffrorna väntar du några minuter och uppdaterar sidan för att se det uppdaterade diagrammet.
- På sidan Service Bus prenumeration visas antalet aktiva meddelanden som noll. Det beror på att en mottagare har tagit emot meddelanden från den här prenumerationen och slutfört meddelandena.

Nästa steg

Se följande dokumentation och exempel:

Kom igång med Azure Service Bus ämnen och prenumerationer (.NET)

Betygsätta din upplevelse

Förutsättningar

Skapa ett namnområde i Azure Portal

Hämta anslutningssträngen

Skapa ett ämne med Azure Portal

Skapa en prenumeration på ämnet

Skicka meddelanden till ämnet

Skapa ett konsolprogram

Lägga till Service Bus-NuGet-paketet

Lägga till kod för att skicka meddelanden till ämnet

Ta emot meddelanden från en prenumeration

Skapa ett projekt för mottagaren

Lägga till Service Bus-NuGet-paketet

Lägga till kod för att ta emot meddelanden från prenumerationen

Nästa steg