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

Artikel
11/21/2023

Dieser Artikel bietet eine Übersicht über Durable Functions im isolierten .NET-Worker. Der isolierte Worker ermöglicht die Ausführung einer Durable Functions-App auf einer anderen .NET-Version als der des Azure Functions-Hosts.

Was spricht für die Verwendung von Durable Functions im isolierten .NET-Worker?

Mit diesem Modell können Sie alle Vorteile nutzen, die der isolierte .NET-Workerprozess von Azure Functions bietet. 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

Orchestrierungseingaben können direkt eingefügt werden: MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)
Unterstützung stark typisierter Aufrufe und klassenbasierter Aktivitäten und Orchestrierungen (HINWEIS: in der Vorschauversion. Weitere Informationen finden Sie hier.)
Plus alle Vorteile des isolierten .NET-Workers von Azure Functions.

Quellgenerator und klassenbasierte Aktivitäten und Orchestrierungen

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

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

Klassenbasierte Aktivitäten und Orchestrierungen, eine alternative Methode 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

[DurableTask(nameof(MyActivity))]
public class MyActivity : TaskActivity<string, string>
{
    private readonly ILogger logger;

    public MyActivity(ILogger<MyActivity> logger) // activities have access to DI.
    {
        this.logger = logger;
    }

    public async override Task<string> RunAsync(TaskActivityContext context, string input)
    {
        // implementation
    }
}

[DurableTask(nameof(MyOrchestration))]
public class MyOrchestration : TaskOrchestrator<string, string>
{
    public async override Task<string> RunAsync(TaskOrchestrationContext context, string input)
    {
        ILogger logger = context.CreateReplaySafeLogger<MyOrchestration>(); // orchestrations do NOT have access to DI.

        // An extension method was generated for directly invoking "MyActivity".
        return await context.CallMyActivityAsync(input);
    }
}

Dauerhafte Entitäten

Dauerhafte Entitäten werden in isolierten .NET-Workerprozessen unterstützt. Siehe Entwicklerhandbuch.

Migrationsleitfaden

In diesem Leitfaden wird davon ausgegangen, dass Sie mit einem .NET Durable Functions 2.x-Projekt beginnen.

Aktualisieren des Projekts

Der erste Schritt besteht darin, Ihr Projekt auf Azure Functions mit isoliertem .NET-Worker zu aktualisieren. Aktualisieren Sie anschließend die Durable Functions NuGet-Paketverweise.

Alt:

<ItemGroup>
  <PackageReference Include="Microsoft.Azure.WebJobs.Extensions.DurableTask" Version="2.9.0" />
</ItemGroup>

Neu:

<ItemGroup>
  <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" Version="1.1.0" />
</ItemGroup>

Aktualisieren Ihres Codes

Durable Functions für isolierten .NET-Worker ist ein völlig neues Paket mit unterschiedlichen Typen und Namespaces. Infolgedessen sind Änderungen am Code erforderlich, aber viele der APIs lassen sich ohne Änderungen verwenden.

host.json-Schema

Das Schema für Durable Functions für isolierten .NET-Worker und Durable Functions 2.x ist unverändert, es sollten keine Änderungen erforderlich sein.

Öffentliche API-Änderungen

Diese Tabelle enthält keine vollständige Liste der Änderungen.

2.x	Isolated
`IDurableOrchestrationClient`	`DurableTaskClient`
`IDurableOrchestrationClient.StartNewAsync`	`DurableTaskClient.ScheduleNewOrchestrationInstanceAsync`
`IDurableEntityClient.SignalEntityAsync`	`DurableTaskClient.Entities.SignalEntityAsync`
`IDurableEntityClient.ReadEntityStateAsync`	`DurableTaskClient.Entities.GetEntityAsync`
`IDurableEntityClient.ListEntitiesAsync`	`DurableTaskClient.Entities.GetAllEntitiesAsync`
`IDurableEntityClient.CleanEntityStorageAsync`	`DurableTaskClient.Entities.CleanEntityStorageAsync`
`IDurableOrchestrationContext`	`TaskOrchestrationContext`
`IDurableOrchestrationContext.GetInput<T>()`	`TaskOrchestrationContext.GetInput<T>()` oder Eingabe als Parameter einfügen: `MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)`
`DurableActivityContext`	Keine Entsprechung
`DurableActivityContext.GetInput<T>()`	Einfügen der Eingabe als Parameter `MyActivity([ActivityTrigger] T input)`
`IDurableOrchestrationContext.CallActivityWithRetryAsync`	`TaskOrchestrationContext.CallActivityAsync`, den Parameter `TaskOptions` mit Wiederholungsdetails einschließen.
`IDurableOrchestrationContext.CallSubOrchestratorWithRetryAsync`	`TaskOrchestrationContext.CallSubOrchestratorAsync`, den Parameter `TaskOptions` mit Wiederholungsdetails einschließen.
`IDurableOrchestrationContext.CallHttpAsync`	`TaskOrchestrationContext.CallHttpAsync`
`IDurableOrchestrationContext.CreateReplaySafeLogger(ILogger)`	`TaskOrchestrationContext.CreateReplaySafeLogger<T>()` oder `TaskOrchestrationContext.CreateReplaySafeLogger(string)`
`IDurableOrchestrationContext.CallEntityAsync`	`TaskOrchestrationContext.Entities.CallEntityAsync`
`IDurableOrchestrationContext.SignalEntity`	`TaskOrchestrationContext.Entities.SignalEntityAsync`
`IDurableOrchestrationContext.LockAsync`	`TaskOrchestrationContext.Entities.LockEntitiesAsync`
`IDurableOrchestrationContext.IsLocked`	`TaskOrchestrationContext.Entities.InCriticalSection`
`IDurableEntityContext`	`TaskEntityContext`.
`IDurableEntityContext.EntityName`	`TaskEntityContext.Id.Name`
`IDurableEntityContext.EntityKey`	`TaskEntityContext.Id.Key`
`IDurableEntityContext.OperationName`	`TaskEntityOperation.Name`
`IDurableEntityContext.FunctionBindingContext`	Entfernt, fügen Sie `FunctionContext` als Eingabeparameter hinzu
`IDurableEntityContext.HasState`	`TaskEntityOperation.State.HasState`
`IDurableEntityContext.BatchSize`	Entfernt
`IDurableEntityContext.BatchPosition`	Entfernt
`IDurableEntityContext.GetState`	`TaskEntityOperation.State.GetState`
`IDurableEntityContext.SetState`	`TaskEntityOperation.State.SetState`
`IDurableEntityContext.DeleteState`	`TaskEntityOperation.State.SetState(null)`
`IDurableEntityContext.GetInput`	`TaskEntityOperation.GetInput`
`IDurableEntityContext.Return`	Entfernt. Stattdessen wird der Rückgabewert der Methode verwendet.
`IDurableEntityContext.SignalEntity`	`TaskEntityContext.SignalEntity`
`IDurableEntityContext.StartNewOrchestration`	`TaskEntityContext.ScheduleNewOrchestration`
`IDurableEntityContext.DispatchAsync`	`TaskEntityDispatcher.DispatchAsync`. Konstruktorparameter entfernt.
`IDurableOrchestrationClient.GetStatusAsync`	`DurableTaskClient.GetInstanceAsync`

Verhaltensänderungen

Das Standardverhalten der Serialisierung hat sich von Newtonsoft.Json in System.Text.Jsongeändert. Weitere Informationen finden Sie hier.

Freigeben über