Omówienie rozszerzenia Durable Functions w izolowanym procesie roboczym platformy .NET

Artykuł
11/16/2023

Ten artykuł zawiera omówienie rozszerzenia Durable Functions w izolowanym procesie roboczym platformy .NET. Izolowany proces roboczy umożliwia uruchamianie aplikacji Durable Functions na platformie .NET w wersji innej niż host usługi Azure Functions.

Dlaczego warto używać rozszerzenia Durable Functions w izolowanym procesie roboczym platformy .NET?

Użycie tego modelu umożliwia uzyskanie wszystkich wielkich korzyści, które są dostarczane z procesem roboczym izolowanym platformy Azure Functions platformy .NET. Aby uzyskać więcej informacji, zobacz Zalety izolowanego modelu procesu roboczego. Ponadto ten nowy zestaw SDK zawiera kilka nowych funkcji.

Ulepszenia funkcji w procesie Durable Functions

Dane wejściowe aranżacji można wprowadzać bezpośrednio: MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)
Obsługa silnie typiowanych wywołań i działań opartych na klasach i aranżacji (UWAGA: w wersji zapoznawczej. Aby uzyskać więcej informacji, zobacz tutaj.
Ponadto wszystkie korzyści wynikające z izolowanego procesu roboczego platformy .NET usługi Azure Functions.

Generator źródła i działania oparte na klasach oraz aranżacje

Wymaganie: dodaj <PackageReference Include="Microsoft.DurableTask.Generators" Version="1.0.0-preview.1" /> do projektu.

Dodając pakiet generatora źródłowego, uzyskujesz dostęp do dwóch nowych funkcji:

Działania oparte na klasach i aranżacje, alternatywny sposób pisania funkcji Durable Functions. Zamiast "opartych na funkcjach" piszesz silnie typizowane klasy, które dziedziczą typy z zestawu Durable SDK.
Silnie typizowane metody rozszerzenia do wywoływania podaranżów i działań. Te metody rozszerzenia mogą być również używane z działań i aranżacji opartych na funkcjach.

Przykład oparty na funkcjach

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

Przykład oparty na klasach

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

    public MyActivity(ILogger<MyActivity> logger) // activites 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);
    }
}

Jednostki trwałe

Jednostki trwałe są obsługiwane w izolowanym procesie roboczym platformy .NET. Zobacz przewodnik dewelopera.

Przewodnik migracji

W tym przewodniku założono, że zaczynasz od projektu durable functions platformy .NET 2.x.

Aktualizowanie projektu

Pierwszym krokiem jest zaktualizowanie projektu do izolowanej platformy .NET usługi Azure Functions. Następnie zaktualizuj odwołania do pakietu NuGet rozszerzenia Durable Functions.

Stary:

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

Nowa:

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

Aktualizowanie kodu

Rozszerzenie Durable Functions dla izolowanego procesu roboczego platformy .NET to zupełnie nowy pakiet z różnymi typami i przestrzeniami nazw. W rezultacie istnieją wymagane zmiany w kodzie, ale wiele interfejsów API jest w kolejce bez konieczności wprowadzania zmian.

Schemat Host.json

Schemat dla izolowanego procesu roboczego platformy Durable Functions .NET i rozszerzenia Durable Functions 2.x pozostał taki sam. Nie należy stosować żadnych zmian.

Zmiany publicznego interfejsu API

Ta tabela nie jest wyczerpującą listą zmian.

2.x	Izolowana
`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>()` lub wstrzyknąć dane wejściowe jako parametr: `MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)`
`DurableActivityContext`	Brak odpowiednika
`DurableActivityContext.GetInput<T>()`	Wstrzykiwanie danych wejściowych jako parametru `MyActivity([ActivityTrigger] T input)`
`IDurableOrchestrationContext.CallActivityWithRetryAsync`	`TaskOrchestrationContext.CallActivityAsync`, dołącz `TaskOptions` parametr ze szczegółami ponawiania prób.
`IDurableOrchestrationContext.CallSubOrchestratorWithRetryAsync`	`TaskOrchestrationContext.CallSubOrchestratorAsync`, dołącz `TaskOptions` parametr ze szczegółami ponawiania prób.
`IDurableOrchestrationContext.CallHttpAsync`	`TaskOrchestrationContext.CallHttpAsync`
`IDurableOrchestrationContext.CreateReplaySafeLogger(ILogger)`	`TaskOrchestrationContext.CreateReplaySafeLogger<T>()` lub `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`	Usunięto, dodaj `FunctionContext` jako parametr wejściowy
`IDurableEntityContext.HasState`	`TaskEntityOperation.State.HasState`
`IDurableEntityContext.BatchSize`	Usunięte
`IDurableEntityContext.BatchPosition`	Usunięte
`IDurableEntityContext.GetState`	`TaskEntityOperation.State.GetState`
`IDurableEntityContext.SetState`	`TaskEntityOperation.State.SetState`
`IDurableEntityContext.DeleteState`	`TaskEntityOperation.State.SetState(null)`
`IDurableEntityContext.GetInput`	`TaskEntityOperation.GetInput`
`IDurableEntityContext.Return`	Usuwane. Zamiast tego użyto wartości zwracanej przez metodę.
`IDurableEntityContext.SignalEntity`	`TaskEntityContext.SignalEntity`
`IDurableEntityContext.StartNewOrchestration`	`TaskEntityContext.ScheduleNewOrchestration`
`IDurableEntityContext.DispatchAsync`	`TaskEntityDispatcher.DispatchAsync`. Usunięto parametry konstruktora.

Zmiany zachowań

Domyślne zachowanie serializacji zostało zmienione z Newtonsoft.Json na System.Text.Json. Więcej informacji można znaleźć tutaj.