Asynchrone Zustandsverwaltung

Das 📦 Microsoft.Extensions.AsyncState NuGet-Paket bietet Funktionen zum Speichern und Abrufen von Objekten im aktuellen asynchronen Kontext. Dieses Paket bietet Leistungs- und Benutzerfreundlichkeitsverbesserungen gegenüber der direkten Verwendung AsyncLocal<T> , insbesondere, wenn mehrere Objekte für asynchrone Vorgänge freigegeben werden müssen.

Gründe für die Verwendung von AsyncState

Während .NET AsyncLocal<T> für die Verwaltung von Umgebungsdaten in asynchronen Kontexten bereitstellt, kann die Verwendung direkt Nachteile haben:

  • Leistung: Jede AsyncLocal<T> Instanz erhöht mehr Aufwand. Wenn mehrere Objekte über asynchrone Kontexte fließen müssen, kann sich die Verwaltung vieler AsyncLocal<T> Instanzen auf die Leistung auswirken.
  • Abstraktion: Die direkte Verwendung von AsyncLocal<T> bindet Ihren Code an eine bestimmte Implementierung, was es schwieriger macht, ihn in Zukunft zu optimieren oder zu ändern.
  • Lebensdauerverwaltung: Das AsyncState-Paket bietet eine bessere Kontrolle über die Lebensdauer von Umgebungsdaten über explizite APIs.

Das Microsoft.Extensions.AsyncState Paket behebt diese Bedenken, indem Folgendes bereitgestellt wird:

  • Eine optimierte Implementierung, die die Anzahl der AsyncLocal<T> benötigten Instanzen reduziert.
  • Eine saubere Abstraktion zum Speichern und Abrufen von Umgebungsdaten.
  • Integration mit Abhängigkeitsinjektion für einfachere Tests und Konfiguration.

Loslegen

Um mit der asynchronen Zustandsverwaltung zu beginnen, installieren Sie das Microsoft.Extensions.AsyncState NuGet-Paket.

dotnet add package Microsoft.Extensions.AsyncState

Weitere Informationen finden Sie unter dotnet add package or Manage package dependencies in .NET applications.

Asynchrone Zustandsdienste registrieren

Mithilfe der AddAsyncState Erweiterungsmethode registrieren Sie die asynchronen Zustandsdienste im Container für die Abhängigkeitsinjektion.

using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();

services.AddAsyncState();

ServiceProvider provider = services.BuildServiceProvider();

Diese Registrierung macht die Schnittstellen IAsyncContext<T> und IAsyncState für die Abhängigkeitsinjektion verfügbar.

Verwenden von IAsyncContext

Die IAsyncContext<T> Schnittstelle stellt Methoden zum Abrufen und Festlegen von Werten im aktuellen asynchronen Kontext bereit:

var context = provider.GetRequiredService<IAsyncContext<UserContext>>();

// Set a value in the async context
var userContext = new UserContext { UserId = "12345", UserName = "Alice" };
context.Set(userContext);

// Retrieve the value
if (context.TryGet(out var retrievedContext))
{
    Console.WriteLine($"User: {retrievedContext.UserName}");
}

public record class UserContext
{
    public required string UserId { get; set; }
    public required string UserName { get; set; }
}

Der im Kontext festgelegte Wert fließt über asynchrone Vorgänge, sodass er für den gesamten Code verfügbar ist, der innerhalb desselben asynchronen Kontexts ausgeführt wird.

Verwenden von IAsyncState

Die IAsyncState-Schnittstelle ist die Basisschnittstelle des Lebenszyklus, welche IAsyncContext<T> erweitert. Sie stellt Initialize() und Reset() Methoden zum Verwalten des asynchronen Zustandslebenszyklus bereit. Verwenden Sie stattdessen IAsyncContext<T> für typisierten Zugriff auf asynchrone Zustandswerte.

Praktisches Beispiel: Anforderungskorrelation

Ein gängiger Anwendungsfall für den asynchronen Zustand besteht darin, Korrelationsinformationen über eine HTTP-Anforderung hinweg beizubehalten:

public class RequestProcessor(IAsyncContext<CorrelationContext> asyncContext)
{

    public async Task ProcessRequestAsync(string correlationId)
    {
        // Set correlation context at the beginning of request processing
        asyncContext.Set(new CorrelationContext { CorrelationId = correlationId });

        // The correlation ID flows through all async operations
        await Step1Async();
        await Step2Async();
    }

    private async Task Step1Async()
    {
        await Task.Yield();
        
        if (asyncContext.TryGet(out var context))
        {
            Console.WriteLine($"Step 1 - Correlation ID: {context.CorrelationId}");
        }
    }

    private async Task Step2Async()
    {
        await Task.Yield();
        
        if (asyncContext.TryGet(out var context))
        {
            Console.WriteLine($"Step 2 - Correlation ID: {context.CorrelationId}");
        }
    }
}

public class CorrelationContext
{
    public required string CorrelationId { get; set; }
}

In diesem Beispiel wird die Korrelations-ID einmal am Anfang der Anforderungsverarbeitung festgelegt und ist automatisch in allen nachfolgenden asynchronen Vorgängen verfügbar, ohne sie als Parameter übergeben zu müssen.

ASP.NET Core-Integration

In ASP.NET Core Anwendungen können Sie den asynchronen Zustand verwenden, um anforderungsspezifische Informationen über Ihre Anwendung zu flussen:

public class RequestHandler(IAsyncContext<RequestMetadata> asyncContext)
{

    public async Task<object> GetDataAsync()
    {
        await Task.Yield();
        
        if (asyncContext.TryGet(out var metadata))
        {
            var duration = DateTimeOffset.UtcNow - metadata.StartTime;
            return new
            {
                RequestId = metadata.RequestId,
                RequestPath = metadata.RequestPath,
                Duration = duration.TotalMilliseconds
            };
        }

        return new { Error = "No request metadata available" };
    }
}

public record class RequestMetadata
{
    public required string RequestId { get; set; }
    public required string RequestPath { get; set; }
    public DateTimeOffset StartTime { get; set; }
}

Bewährte Methoden

Berücksichtigen Sie bei verwendung des asynchronen Zustands die folgenden bewährten Methoden:

  • Beschränken Sie die Statusgröße: Halten Sie asynchrone Zustandsobjekte klein, um den Arbeitsspeicheraufwand zu reduzieren und die Leistung zu gewährleisten.
  • Initialisieren Sie den Zustand frühzeitig: Legen Sie asynchrone Statuswerte so früh wie möglich fest, um sicherzustellen, dass sie für alle nachgeschalteten asynchronen Vorgänge verfügbar sind.
  • Bereinigungszustand: Setzt den asynchronen Zustand zurück oder löscht ihn, wenn er nicht mehr benötigt wird, um Speicherverluste in lang ausgeführten Anwendungen zu vermeiden.
  • Verwenden Sie geeignete Schnittstellen: Verwenden Sie diese Option IAsyncContext<T> , um eingegebene Werte im aktuellen asynchronen Kontext abzurufen und festzulegen. Verwenden Sie IAsyncState, wenn Sie den Initialisierungs- und Zurücksetzungslebenszyklus direkt verwalten müssen.
  • Type safety: Erstellen Sie bestimmte Kontexttypen, anstatt generische Wörterbücher zu verwenden, um die Typsicherheit aufrechtzuerhalten und code clarity zu verbessern.

Siehe auch

  • Last updated on