Übersicht über Durable Functions im isolierten .NET-Worker

Dieser Artikel enthält eine Übersicht über Durable Functions im isolierten .NET Worker. Der isolierte Worker ermöglicht es Ihrer Durable Functions-App, auf einer anderen .NET-Version als der Version des Azure Functions Hosts ausgeführt zu werden.

Warum Durable Functions im isolierten .NET Worker verwenden?

Mit diesem Modell erhalten Sie alle großen Vorteile, die im Azure Functions .NET isolierten Arbeitsprozess enthalten sind. Weitere Informationen finden Sie unter "Vorteile des isolierten Arbeitsmodells". Darüber hinaus enthält dieses neue SDK einige neue Features.

Featureverbesserungen gegenüber prozessinternen Durable Functions

• Die Orchestrierungseingabe kann direkt eingefügt werden: MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)
• Unterstützung für stark typisierte Aufrufe und klassenbasierte Aktivitäten und Orchestrierungen (HINWEIS: in der Vorschau). Weitere Informationen finden Sie unter Quellengenerator und klassenbasierte Aktivitäten und Orchestrierungen.
• Plus alle Vorteile des Azure Functions .NET isolierten Arbeiters.

Quellgenerator und klassenbasierte Aktivitäten und Orchestrierungen

Anforderung: Fügen Sie <PackageReference Include="Microsoft.DurableTask.Generators" Version="1.0.0" /> zu Ihrem Projekt hinzu.

Durch Hinzufügen des Quellgeneratorpakets erhalten Sie Zugriff auf zwei neue Features:

• Klassenbasierte Aktivitäten und Orchestrierungen, eine alternative Möglichkeit zum Schreiben von Durable Functions. Statt „funktionsbasiertem“ Code schreiben Sie stark typisierte Klassen, die Typen vom Durable SDK erben.
• Stark typisierte Erweiterungsmethoden zum Aufrufen von untergeordneten Orchestrierungen und Aktivitäten. Diese Erweiterungsmethoden können auch von „funktionsbasierten“ Aktivitäten und Orchestrierungen verwendet werden.

Funktionsbasiertes Beispiel

public static class MyFunctions
{
    [Function(nameof(MyActivity))] 
    public static async Task<string> MyActivity([ActivityTrigger] string input)
    {
        // implementation
    }

    [Function(nameof(MyOrchestration))] 
    public static async Task<string> MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, string input)
    {
        // implementation
        return await context.CallActivityAsync(nameof(MyActivity), input);
    }
}

Klassenbasiertes Beispiel (mit Eingabe/Ausgabe)

using Microsoft.DurableTask;

[DurableTask]
public class MyOrchestration : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, string input)
    {
        return await context.CallActivityAsync<string>(nameof(MyActivity), input);
    }
}

[DurableTask]
public class MyActivity : TaskActivity<string, string>
{
    public override Task<string> RunAsync(TaskActivityContext context, string input)
    {
        return Task.FromResult($"Processed: {input}");
    }
}

Ein klassenbasiertes Beispiel (keine Eingabe/Ausgabe ILogger in einer Aktivität)

using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;

[DurableTask]
public class MaintenanceOrchestration : TaskOrchestrator<object?, object?>
{
    public override async Task<object?> RunAsync(TaskOrchestrationContext context, object? input)
    {
        await context.CallActivityAsync(nameof(WriteHeartbeatLogActivity), (object?)null);
        return null;
    }
}

[DurableTask]
public class WriteHeartbeatLogActivity : TaskActivity<object?, object?>
{
    private readonly ILogger<WriteHeartbeatLogActivity> _logger;

    public WriteHeartbeatLogActivity(ILogger<WriteHeartbeatLogActivity> logger)
    {
        _logger = logger;
    }

    public override Task<object?> RunAsync(TaskActivityContext context, object? input)
    {
        _logger.LogInformation("Heartbeat logged at {Timestamp}.", DateTimeOffset.UtcNow);
        return Task.FromResult<object?>(null);
    }
}

Verwenden Sie object? als generisches Typargument für klassenbasierte Orchestrierungen und Aktivitäten, die keine Eingaben oder Ausgaben benötigen. Mit diesem Muster können Sie Abhängigkeitsinjektion (z. B. ILogger<T>) in Aktivitäten verwenden, während Sie weiterhin das klassenbasierte Modell verwenden.

Dauerhafte Entitäten

Dauerhafte Entitäten werden im .NET-isolierten Worker unterstützt. Weitere Informationen finden Sie im Entwicklerhandbuch.

Migrationsleitfaden

Informationen zum Migrieren Ihrer Durable Functions-App vom In-Process-Modell zum .NET-isolierten Worker finden Sie unter Vom In-Process- zum Isolierten Worker-Modell migrieren. Dieser Leitfaden behandelt Projekteinrichtung, Paketverweise, Namespaceänderungen, API-Zuordnungen, Verhaltensunterschiede und häufige Migrationsprobleme.