Azure Service Bus Clientbibliothek für .NET– Version 7.16.2

mit Azure Service Bus können Sie Anwendungen erstellen, die asynchrone Messagingmuster nutzen, indem Sie einen äußerst zuverlässigen Dienst verwenden, um Nachrichten zwischen Produzenten und Consumern zu vermitteln. Azure Service Bus bietet flexibles Brokermessaging zwischen Client und Server sowie strukturiertes First-In-First-Out-Messaging (FIFO) sowie Funktionen zum Veröffentlichen/Abonnieren mit komplexem Routing. Wenn Sie mehr über Azure Service Bus erfahren möchten, können Sie folgendes lesen: Was ist Azure Service Bus?

Verwenden Sie die Clientbibliothek für Azure Service Bus für Folgendes:

• Übertragen von Geschäftsdaten: Nutzen Sie Messaging für einen dauerhaften Austausch von Informationen, z. B. Verkaufs- oder Bestellungen, Journale oder Bestandsverschiebungen.

• Entkoppeln von Anwendungen: Verbessern Sie die Zuverlässigkeit und Skalierbarkeit von Anwendungen und Diensten, wodurch Absender und Empfänger gleichzeitig online sein müssen.

• Steuern, wie Nachrichten verarbeitet werden: Unterstützen Sie herkömmliche konkurrierende Consumer für Nachrichten, die Warteschlangen verwenden, oder erlauben Sie jedem Consumer seine eigene instance einer Nachricht mithilfe von Themen und Abonnements.

• Implementieren komplexer Workflows: Nachrichtensitzungen unterstützen Szenarien, in denen die Nachrichtenreihenfolge oder Nachrichtenverzögerung erforderlich ist.

Quellcode | Paket (NuGet) | API-Referenzdokumentation | Produktdokumentation | Migrationshandbuch (Microsoft.Azure.ServiceBus) | Migrationshandbuch (WindowsAzure.ServiceBus) | Leitfaden zur Problembehandlung

Erste Schritte

Voraussetzungen

• Microsoft Azure-Abonnement: Für die Verwendung von Azure-Diensten, einschließlich Azure Service Bus, benötigen Sie ein Abonnement. Wenn Sie nicht über ein vorhandenes Azure-Konto verfügen, können Sie sich für eine kostenlose Testversion registrieren oder Ihre MSDN-Abonnentenvorteile nutzen, wenn Sie ein Konto erstellen.

• Service Bus-Namespace: Für die Interaktion mit Azure Service Bus benötigen Sie auch einen Namespace. Wenn Sie mit dem Erstellen von Azure-Ressourcen nicht vertraut sind, können Sie die Schritt-für-Schritt-Anleitung zum Erstellen eines Service Bus-Namespace mithilfe des Azure-Portal befolgen. Dort finden Sie auch ausführliche Anweisungen zur Verwendung der Azure CLI-, Azure PowerShell- oder Arm-Vorlagen (Azure Resource Manager) zum Erstellen einer Service Bus-Entität.

• C# 8.0: Die Azure Service Bus-Clientbibliothek verwendet neue Features, die in C# 8.0 eingeführt wurden. Um die C# 8.0-Syntax nutzen zu können, empfiehlt es sich, das .NET Core SDK 3.0 oder höher mit einer Sprachversion von latestzu kompilieren.

  Visual Studio-Benutzer, die die C# 8.0-Syntax vollständig nutzen möchten, müssen Visual Studio 2019 oder höher verwenden. Visual Studio 2019 (einschließlich der kostenlosen Community-Edition) kann hier heruntergeladen werden. Benutzer von Visual Studio 2017 können die C# 8-Syntax nutzen, indem sie das NuGet-Paket Microsoft.Net.Compilers verwenden und die Sprachversion festlegen, obwohl die Bearbeitungserfahrung möglicherweise nicht ideal ist.

  Sie können die Bibliothek weiterhin mit früheren C#-Sprachversionen verwenden, müssen aber asynchrone aufzählbare und asynchrone verwerfbare Member manuell verwalten, anstatt von der neuen Syntax zu profitieren. Sie können weiterhin jede Frameworkversion verwenden, die von Ihrem .NET Core SDK unterstützt wird, einschließlich früherer Versionen von .NET Core oder .NET Framework. Weitere Informationen finden Sie unter Angeben von Zielframeworks.

  Wichtiger Hinweis: Um die Beispiele und die Beispiele ohne Änderung zu erstellen oder auszuführen, ist die Verwendung von C# 8.0 obligatorisch. Sie können die Beispiele weiterhin ausführen, wenn Sie sie für andere Sprachversionen optimieren möchten.

Um schnell die erforderlichen Service Bus-Ressourcen in Azure zu erstellen und eine Verbindungszeichenfolge für sie zu erhalten, können Sie unsere Beispielvorlage bereitstellen, indem Sie auf Folgendes klicken:

Installieren des Pakets

Installieren Sie die Azure Service Bus-Clientbibliothek für .NET mit NuGet:

dotnet add package Azure.Messaging.ServiceBus

Authentifizieren des Clients

Damit die Service Bus-Clientbibliothek mit einer Warteschlange oder einem Thema interagieren kann, muss sie verstehen, wie eine Verbindung hergestellt und autorisiert werden kann. Die einfachste Möglichkeit hierfür ist die Verwendung eines Verbindungszeichenfolge, der automatisch erstellt wird, wenn ein Service Bus-Namespace erstellt wird. Wenn Sie mit Shared Access-Richtlinien in Azure nicht vertraut sind, können Sie die Schritt-für-Schritt-Anleitung befolgen, um eine Service Bus-Verbindungszeichenfolge zu erhalten.

Sobald Sie über eine Verbindungszeichenfolge verfügen, können Sie Ihren Client damit authentifizieren.

// Create a ServiceBusClient that will authenticate using a connection string
string connectionString = "<connection_string>";
await using var client = new ServiceBusClient(connectionString);

Sehen Sie sich dieses Beispiel an, um zu erfahren, wie Sie sich mit Azure.Identity authentifizieren.

Beispiele für die Authentifizierung für eine ASP.NET Core-Anwendung finden Sie in diesem Beispiel.

In diesem Beispiel erfahren Sie, wie Sie die Verbindung mit einem benutzerdefinierten Endpunkt initiieren.

Wichtige Begriffe

Nachdem Sie ein ServiceBusClientinitialisiert haben, können Sie mit den primären Ressourcentypen in einem Service Bus-Namespace interagieren, von denen mehrere vorhanden sein können, und für die tatsächliche Nachrichtenübertragung erfolgt, der Namespace dient häufig als Anwendungscontainer:

• Warteschlange: Ermöglicht das Senden und Empfangen von Nachrichten. Wird häufig für die Punkt-zu-Punkt-Kommunikation verwendet.

• Thema: Im Gegensatz zu Warteschlangen eignen sich Themen besser für Veröffentlichungs-/Abonnementszenarien. Ein Thema kann an gesendet werden, erfordert jedoch ein Abonnement, von dem mehrere parallel verwendet werden können.

• Abonnement: Der Mechanismus, der aus einem Thema verwendet werden soll. Jedes Abonnement ist unabhängig und empfängt eine Kopie jeder Nachricht, die an das Thema gesendet wird. Mithilfe von Regeln und Filtern können Sie anpassen, welche Nachrichten von einem bestimmten Abonnement empfangen werden.

Weitere Informationen zu diesen Ressourcen finden Sie unter Was ist Azure Service Bus?.

Um mit diesen Ressourcen zu interagieren, sollten Sie mit den folgenden SDK-Konzepten vertraut sein:

• Ein Service Bus-Client ist die primäre Schnittstelle für Entwickler, die mit der Service Bus-Clientbibliothek interagieren. Sie dient als Gateway, von dem aus die gesamte Interaktion mit der Bibliothek erfolgt.

• Ein Service Bus-Absender ist auf eine bestimmte Warteschlange oder ein bestimmtes Thema ausgerichtet und wird mithilfe des Service Bus-Clients erstellt. Mit dem Absender können Sie Nachrichten an eine Warteschlange oder ein Thema senden. Außerdem können Nachrichten so geplant werden, dass sie zu einem bestimmten Datum für die Zustellung verfügbar sind.

• Ein Service Bus-Empfänger ist auf eine bestimmte Warteschlange oder ein bestimmtes Abonnement ausgerichtet und wird mithilfe des Service Bus-Clients erstellt. Mit dem Empfänger können Sie Nachrichten aus einer Warteschlange oder einem Abonnement empfangen. Außerdem können die Nachrichten nach dem Empfang abgerechnet werden. Es gibt vier Möglichkeiten, Nachrichten zu begleichen:

  • Abgeschlossen: Bewirkt, dass die Nachricht aus der Warteschlange oder dem Thema gelöscht wird.
  • Abbrechen: Gibt die Sperre des Empfängers für die Nachricht auf, sodass die Nachricht von anderen Empfängern empfangen werden kann.
  • Zurückstellen: Verschiebt den Empfang der Nachricht auf normalem Wege. Um verzögerte Nachrichten zu empfangen, muss die Sequenznummer der Nachricht beibehalten werden.
  • DeadLetter: Verschiebt die Nachricht in die Warteschlange für unzustellbare Nachrichten. Dadurch wird verhindert, dass die Nachricht erneut empfangen wird. Um Nachrichten aus der Warteschlange für unzustellbare Nachrichten zu empfangen, wird ein Empfänger benötigt, der auf die Warteschlange für unzustellbare Nachrichten festgelegt ist.

• Ein Service Bus-Sitzungsempfänger ist auf eine bestimmte sitzungsfähige Warteschlange oder ein bestimmtes Abonnement ausgerichtet und wird mithilfe des Service Bus-Clients erstellt. Der Sitzungsempfänger ist fast identisch mit dem Standardempfänger, mit dem Unterschied, dass Sitzungsverwaltungsvorgänge verfügbar gemacht werden, die nur für sitzungsfähige Entitäten gelten. Zu diesen Vorgängen gehören das Abrufen und Festlegen des Sitzungszustands sowie das Erneuern von Sitzungssperren.

• Ein Service Bus-Prozessor ist auf eine bestimmte Warteschlange oder ein bestimmtes Abonnement ausgelegt und wird mithilfe des Service Bus-Clients erstellt. Kann ServiceBusProcessor als Abstraktion um eine Reihe von Empfängern betrachtet werden. Es verwendet ein Rückrufmodell, damit Code angegeben werden kann, wenn eine Nachricht empfangen wird und wenn eine Ausnahme auftritt. Es bietet die automatische Vervollständigung von verarbeiteten Nachrichten, die automatische Verlängerung der Nachrichtensperre und die gleichzeitige Ausführung von vom Benutzer angegebenen Ereignishandlern. Aufgrund seines Funktionsumfangs sollte es das Tool zum Schreiben von Anwendungen sein, die von Service Bus-Entitäten empfangen werden. ServiceBusReceiver wird für komplexere Szenarien empfohlen, in denen der Prozessor nicht in der Lage ist, die differenzierte Steuerung bereitzustellen, die bei direkter Verwendung von ServiceBusReceiver zu erwarten ist.

• Ein Service Bus-Sitzungsprozessor ist auf eine bestimmte sitzungsfähige Warteschlange oder ein bestimmtes Abonnement ausgerichtet und wird mithilfe des Service Bus-Clients erstellt. Der Sitzungsprozessor ist fast identisch mit dem Standardprozessor, mit dem Unterschied, dass Sitzungsverwaltungsvorgänge verfügbar gemacht werden, die nur für sitzungsfähige Entitäten gelten.

Weitere Konzepte und ausführlichere Erläuterungen finden Sie unter Erweiterte Service Bus-Features.

Clientlebensdauer

Absender ServiceBusClient, Empfänger und Prozessoren können für die Lebensdauer der Anwendung sicher zwischengespeichert und als Singleton verwendet werden. Dies ist die bewährte Methode, wenn Nachrichten regelmäßig gesendet oder empfangen werden. Sie sind für eine effiziente Verwaltung der Netzwerk-, CPU- und Arbeitsspeichernutzung verantwortlich und arbeiten daran, die Nutzung in Zeiten der Inaktivität niedrig zu halten.

Diese Typen sind verwerfbar und das Aufrufen von oder DisposeAsyncCloseAsync ist erforderlich, um sicherzustellen, dass Netzwerkressourcen und andere nicht verwaltete Objekte ordnungsgemäß bereinigt werden. Es ist wichtig zu beachten, dass beim Löschen eines ServiceBusClient instance automatisch alle Absender, Empfänger und Prozessoren, die mit dem Instance erstellt wurden, geschlossen und bereinigt.

Threadsicherheit

Wir garantieren, dass alle Client-instance Methoden threadsicher und unabhängig voneinander sind (Richtlinie). Dadurch wird sichergestellt, dass die Empfehlung, Clientinstanzen wiederzuverwenden, immer sicher ist, auch über Threads hinweg.

Zusätzliche Konzepte

Clientoptionen | Diagnose | Spott

Beispiele

• Azure Service Bus-Clientbibliothek für .NET
  • Erste Schritte
    • Voraussetzungen
    • Paket installieren
    • Authentifizieren des Clients
  • Wichtige Begriffe
    • Clientlebensdauer
    • Threadsicherheit
    • Zusätzliche Konzepte
  • Beispiele
    • Senden und Empfangen einer Nachricht
    • Senden eines Nachrichtenbatches
    • Empfangen eines Batches von Nachrichten
    • Abschließen einer Nachricht
    • Verlassen einer Nachricht
    • Zurückstellen einer Nachricht
    • Unzustellbare Nachrichten
    • Verwenden des Prozessors
    • Authentifizieren mit Azure.Identity
    • Registrieren mit ASP.NET Core Abhängigkeitsinjektion
    • Arbeiten mit Sitzungen
  • Problembehandlung
  • Nächste Schritte
  • Mitwirken

Senden und Empfangen einer Nachricht

Das Senden von Nachrichten erfolgt mithilfe von ServiceBusSender. Der Empfang erfolgt mithilfe von ServiceBusReceiver.

string connectionString = "<connection_string>";
string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);

// create the sender
ServiceBusSender sender = client.CreateSender(queueName);

// create a message that we can send. UTF-8 encoding is used when providing a string.
ServiceBusMessage message = new ServiceBusMessage("Hello world!");

// send the message
await sender.SendMessageAsync(message);

// create a receiver that we can use to receive the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);

// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// get the message body as a string
string body = receivedMessage.Body.ToString();
Console.WriteLine(body);

Senden eines Nachrichtenbatches

Es gibt zwei Möglichkeiten, mehrere Nachrichten gleichzeitig zu senden. Die erste Möglichkeit hierfür ist sichere Batchverarbeitung. Mit der sicheren Batchverarbeitung können Sie ein ServiceBusMessageBatch -Objekt erstellen, mit dem Sie versuchen können, nachrichten einzeln zum Batch hinzuzufügen, indem Sie die TryAdd -Methode verwenden. Wenn die Nachricht nicht in den Batch passt, TryAdd wird false zurückgegeben.

// add the messages that we plan to send to a local queue
Queue<ServiceBusMessage> messages = new Queue<ServiceBusMessage>();
messages.Enqueue(new ServiceBusMessage("First message"));
messages.Enqueue(new ServiceBusMessage("Second message"));
messages.Enqueue(new ServiceBusMessage("Third message"));

// create a message batch that we can send
// total number of messages to be sent to the Service Bus queue
int messageCount = messages.Count;

// while all messages are not sent to the Service Bus queue
while (messages.Count > 0)
{
    // start a new batch
    using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();

    // add the first message to the batch
    if (messageBatch.TryAddMessage(messages.Peek()))
    {
        // dequeue the message from the .NET queue once the message is added to the batch
        messages.Dequeue();
    }
    else
    {
        // if the first message can't fit, then it is too large for the batch
        throw new Exception($"Message {messageCount - messages.Count} is too large and cannot be sent.");
    }

    // add as many messages as possible to the current batch
    while (messages.Count > 0 && messageBatch.TryAddMessage(messages.Peek()))
    {
        // dequeue the message from the .NET queue as it has been added to the batch
        messages.Dequeue();
    }

    // now, send the batch
    await sender.SendMessagesAsync(messageBatch);

    // if there are any remaining messages in the .NET queue, the while loop repeats
}

Die zweite Methode verwendet die SendMessagesAsync Überladung, die eine IEnumerable von ServiceBusMessageakzeptiert. Mit dieser Methode versuchen wir, alle bereitgestellten Nachrichten in einen einzelnen Nachrichtenbatch einzupassen, den wir an den Dienst senden. Wenn die Nachrichten zu groß sind, um in einen einzelnen Batch zu passen, löst der Vorgang eine Ausnahme aus.

IList<ServiceBusMessage> messages = new List<ServiceBusMessage>();
messages.Add(new ServiceBusMessage("First"));
messages.Add(new ServiceBusMessage("Second"));
// send the messages
await sender.SendMessagesAsync(messages);

Empfangen eines Batches von Nachrichten

// create a receiver that we can use to receive the messages
ServiceBusReceiver receiver = client.CreateReceiver(queueName);

// the received message is a different type as it contains some service set properties
// a batch of messages (maximum of 2 in this case) are received
IReadOnlyList<ServiceBusReceivedMessage> receivedMessages = await receiver.ReceiveMessagesAsync(maxMessages: 2);

// go through each of the messages received
foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
{
    // get the message body as a string
    string body = receivedMessage.Body.ToString();
}

Abschließen einer Nachricht

Um eine Nachricht aus einer Warteschlange oder einem Abonnement zu entfernen, können wir die CompleteMessageAsync -Methode aufrufen.

string connectionString = "<connection_string>";
string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);

// create the sender
ServiceBusSender sender = client.CreateSender(queueName);

// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage("Hello world!");

// send the message
await sender.SendMessageAsync(message);

// create a receiver that we can use to receive and settle the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);

// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// complete the message, thereby deleting it from the service
await receiver.CompleteMessageAsync(receivedMessage);

Verlassen einer Nachricht

Durch das Verlassen einer Nachricht wird die Sperre des Empfängers aufgehoben, wodurch die Nachricht von diesem oder anderen Empfängern empfangen werden kann.

ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// abandon the message, thereby releasing the lock and allowing it to be received again by this or other receivers
await receiver.AbandonMessageAsync(receivedMessage);

Zurückstellen einer Nachricht

Durch das Zurückstellen einer Nachricht wird verhindert, dass sie mit den ReceiveMessageAsync Methoden oder ReceiveMessagesAsync erneut empfangen wird. Stattdessen gibt es separate Methoden ReceiveDeferredMessageAsync und ReceiveDeferredMessagesAsync zum Empfangen von verzögerten Nachrichten.

ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// defer the message, thereby preventing the message from being received again without using
// the received deferred message API.
await receiver.DeferMessageAsync(receivedMessage);

// receive the deferred message by specifying the service set sequence number of the original
// received message
ServiceBusReceivedMessage deferredMessage = await receiver.ReceiveDeferredMessageAsync(receivedMessage.SequenceNumber);

Unzustellbare Nachrichten

Das Unzustellbare Schreiben einer Nachricht ähnelt dem Zurückstellen einer Standard Unterschied darin, dass Nachrichten automatisch vom Dienst unzustellbar sind, nachdem sie eine bestimmte Anzahl von Nachrichten empfangen haben. Anwendungen können basierend auf ihren Anforderungen manuell unzustellbare Nachrichten auswählen. Wenn eine Nachricht unzustellbar ist, wird sie tatsächlich in eine Unterwarteschlange der ursprünglichen Warteschlange verschoben. Beachten Sie, dass zum ServiceBusReceiver Empfangen von Nachrichten aus der Unterwarteschlange für unzustellbare Nachrichten verwendet wird, unabhängig davon, ob die Standard Warteschlange sitzungsfähig ist.

ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// Dead-letter the message, thereby preventing the message from being received again without receiving from the dead letter queue.
// We can optionally pass a dead letter reason and dead letter description to further describe the reason for dead-lettering the message.
await receiver.DeadLetterMessageAsync(receivedMessage, "sample reason", "sample description");

// receive the dead lettered message with receiver scoped to the dead letter queue.
ServiceBusReceiver dlqReceiver = client.CreateReceiver(queueName, new ServiceBusReceiverOptions
{
    SubQueue = SubQueue.DeadLetter
});
ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveMessageAsync();

// The reason and the description that we specified when dead-lettering the message will be available in the received dead letter message.
string reason = dlqMessage.DeadLetterReason;
string description = dlqMessage.DeadLetterErrorDescription;

Weitere Informationen finden Sie in der Übersicht über ServiceBus-Warteschlangen für unzustellbare Nachrichten.

Verwenden des Prozessors

Kann ServiceBusProcessor als Abstraktion um eine Reihe von Empfängern betrachtet werden. Es verwendet ein Rückrufmodell, damit Code angegeben werden kann, wenn eine Nachricht empfangen wird und wenn eine Ausnahme auftritt. Es bietet die automatische Vervollständigung von verarbeiteten Nachrichten, die automatische Verlängerung der Nachrichtensperre und die gleichzeitige Ausführung von vom Benutzer angegebenen Ereignishandlern. Aufgrund seines Funktionsumfangs sollte es das Tool zum Schreiben von Anwendungen sein, die von Service Bus-Entitäten empfangen werden. ServiceBusReceiver wird für komplexere Szenarien empfohlen, in denen der Prozessor nicht in der Lage ist, die differenzierte Steuerung bereitzustellen, die bei direkter Verwendung von ServiceBusReceiver zu erwarten ist.

string connectionString = "<connection_string>";
string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);

// create the sender
ServiceBusSender sender = client.CreateSender(queueName);

// create a set of messages that we can send
ServiceBusMessage[] messages = new ServiceBusMessage[]
{
    new ServiceBusMessage("First"),
    new ServiceBusMessage("Second")
};

// send the message batch
await sender.SendMessagesAsync(messages);

// create the options to use for configuring the processor
var options = new ServiceBusProcessorOptions
{
    // By default or when AutoCompleteMessages is set to true, the processor will complete the message after executing the message handler
    // Set AutoCompleteMessages to false to [settle messages](/azure/service-bus-messaging/message-transfers-locks-settlement#peeklock) on your own.
    // In both cases, if the message handler throws an exception without settling the message, the processor will abandon the message.
    AutoCompleteMessages = false,

    // I can also allow for multi-threading
    MaxConcurrentCalls = 2
};

// create a processor that we can use to process the messages
await using ServiceBusProcessor processor = client.CreateProcessor(queueName, options);

// configure the message and error handler to use
processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;

async Task MessageHandler(ProcessMessageEventArgs args)
{
    string body = args.Message.Body.ToString();
    Console.WriteLine(body);

    // we can evaluate application logic and use that to determine how to settle the message.
    await args.CompleteMessageAsync(args.Message);
}

Task ErrorHandler(ProcessErrorEventArgs args)
{
    // the error source tells me at what point in the processing an error occurred
    Console.WriteLine(args.ErrorSource);
    // the fully qualified namespace is available
    Console.WriteLine(args.FullyQualifiedNamespace);
    // as well as the entity path
    Console.WriteLine(args.EntityPath);
    Console.WriteLine(args.Exception.ToString());
    return Task.CompletedTask;
}

// start processing
await processor.StartProcessingAsync();

// since the processing happens in the background, we add a Console.ReadKey to allow the processing to continue until a key is pressed.
Console.ReadKey();

Authentifizieren mit Azure.Identity

Die Azure Identity-Bibliothek bietet einfache Azure Active Directory-Unterstützung für die Authentifizierung.

// Create a ServiceBusClient that will authenticate through Active Directory
string fullyQualifiedNamespace = "yournamespace.servicebus.windows.net";
await using var client = new ServiceBusClient(fullyQualifiedNamespace, new DefaultAzureCredential());

Arbeiten mit Sitzungen

Sitzungen bieten einen Mechanismus zum Gruppieren verwandter Nachrichten. Um Sitzungen verwenden zu können, müssen Sie mit einer sitzungsfähigen Entität arbeiten.

• Sending and receiving session messages (Senden und Empfangen von Sitzungsnachrichten)
• Using the session processor (Verwenden des Sitzungsprozessors)

Registrieren mit ASP.NET Core Abhängigkeitsinjektion

Um als Abhängigkeit in eine ASP.NET Core-App einzufügenServiceBusClient, installieren Sie die Integration der Azure-Clientbibliothek für ASP.NET Core Paket.

dotnet add package Microsoft.Extensions.Azure

Registrieren Sie dann den Client, in dem Ihre Dienste konfiguriert sind. Bei ASP.NET Core Anwendungen befindet sich dies häufig direkt in Program.cs oder der StartupConfigureServices -Methode:

public void ConfigureServices(IServiceCollection services)
{
    services.AddAzureClients(builder =>
    {
        builder.AddServiceBusClient("<< SERVICE BUS CONNECTION STRING >>");
    });

    // Register other services, controllers, and other infrastructure.
}

Bei Anwendungen, die die Verwendung freigegebener Azure.Identity Anmeldeinformationen für ihre Clients bevorzugen, sieht die Registrierung etwas anders aus:

public void ConfigureServices(IServiceCollection services)
 {
     services.AddAzureClients(builder =>
     {
         // This will register the ServiceBusClient using an Azure Identity credential.
         builder.AddServiceBusClientWithNamespace("<< YOUR NAMESPACE >>.servicebus.windows.net");

         // By default, DefaultAzureCredential is used, which is likely desired for most
         // scenarios. If you need to restrict to a specific credential instance, you could
         // register that instance as the default credential instead.
         builder.UseCredential(new ManagedIdentityCredential());
     });

     // Register other services, controllers, and other infrastructure.
 }

Es ist auch möglich, Unterclients wie ServiceBusSender und ServiceBusReceiver mit DI mithilfe der registrierten ServiceBusClient instance zu registrieren. So registrieren Sie beispielsweise einen Absender für jede Warteschlange, die zum Namespace gehört:

public async Task ConfigureServicesAsync(IServiceCollection services)
{
    // Query the available queues for the Service Bus namespace.
    var adminClient = new ServiceBusAdministrationClient("<< SERVICE BUS CONNECTION STRING >>");
    var queueNames = new List<string>();

    // Because the result is async, they need to be captured to a standard list to avoid async
    // calls when registering.  Failure to do so results in an error with the services collection.
    await foreach (var queue in adminClient.GetQueuesAsync())
    {
        queueNames.Add(queue.Name);
    }

    // After registering the ServiceBusClient, register a named factory for each
    // queue.  This allows them to be lazily created and managed as singleton instances.

    services.AddAzureClients(builder =>
    {
        builder.AddServiceBusClient("<< SERVICE BUS CONNECTION STRING >>");

        foreach (var queueName in queueNames)
        {
            builder.AddClient<ServiceBusSender, ServiceBusClientOptions>((_, _, provider) =>
                provider
                    .GetService<ServiceBusClient>()
                    .CreateSender(queueName)
            )
            .WithName(queueName);
        }
    });

    // Register other services, controllers, and other infrastructure.
}

Da die Absender für ihre zugeordnete Warteschlange benannt sind, binden Sie beim Einfügen nicht direkt an sie. Stattdessen binden Sie an eine Factory, die zum Abrufen des benannten Absenders verwendet werden kann:

public class ServiceBusSendingController : ControllerBase
{
    private readonly ServiceBusSender _sender;

    public ServiceBusSendingController(IAzureClientFactory<ServiceBusSender> serviceBusSenderFactory)
    {
        // Though the method is called "CreateClient", the factory will manage the sender as a
        // singleton, creating a new instance only on the first use.
        _sender = serviceBusSenderFactory.CreateClient("<< QUEUE NAME >>");
    }
}

Weitere Informationen und Beispiele finden Sie unter Dependency Injection mit dem Azure SDK für .NET.

Problembehandlung

Weitere Informationen finden Sie im Leitfaden zur Problembehandlung für Service Bus.

Nächste Schritte

Neben den vorgestellten Einführungsszenarien bietet die Azure Service Bus-Clientbibliothek Unterstützung für zusätzliche Szenarien, um den vollständigen Funktionsumfang des Azure Service Bus-Diensts zu nutzen. Um einige dieser Szenarien zu erkunden, bietet die Service Bus-Clientbibliothek ein Projekt mit Beispielen, die als Veranschaulichung für gängige Szenarien dienen. Weitere Informationen finden Sie in der Infodatei zu Den Beispielen .

Mitwirken

Beiträge und Vorschläge für dieses Projekt sind willkommen. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. Ausführliche Informationen finden Sie unter https://cla.microsoft.com.

Wenn Sie einen Pull Request (PR) übermitteln, überprüft ein CLA-Bot automatisch, ob Sie eine Lizenzvereinbarung bereitstellen und den PR entsprechend ergänzen müssen (z.B. mit einer Bezeichnung oder einem Kommentar). Führen Sie einfach die Anweisungen des Bots aus. Sie müssen dies nur einmal für alle Repositorys ausführen, die unsere CLA verwenden.

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Anmerkungen haben.

Weitere Informationen finden Sie in unserem Leitfaden für Beiträge .