Přehled Durable Functions v izolovaném pracovním procesu .NET

Článek
11/16/2023

Tento článek obsahuje přehled Durable Functions v izolovaném pracovním procesu .NET. Izolovaný pracovní proces umožňuje, aby aplikace Durable Functions běžela na jiné verzi .NET než na hostiteli Azure Functions.

Proč používat Durable Functions v izolovaném pracovním procesu .NET?

Pomocí tohoto modelu získáte všechny skvělé výhody, které jsou součástí izolovaného pracovního procesu Azure Functions .NET. Další informace naleznete v tématu Výhody izolovaného modelu pracovního procesu. Kromě toho tato nová sada SDK obsahuje některé nové funkce.

Vylepšení funkcí v procesu Durable Functions

Vstup orchestrace lze přímo vkládat: MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)
Podpora volání silného typu a aktivit a orchestrací založených na třídách (POZNÁMKA: ve verzi Preview Další informace najdete tady.)
Navíc všechny výhody izolovaného pracovního procesu Azure Functions .NET.

Generátor zdrojů a aktivity a orchestrace založené na třídách

Požadavek: přidejte <PackageReference Include="Microsoft.DurableTask.Generators" Version="1.0.0-preview.1" /> do projektu.

Přidáním zdrojového balíčku generátoru získáte přístup ke dvěma novým funkcím:

Aktivity a orchestrace založené na třídách, alternativní způsob psaní Durable Functions. Místo "funkčních" napíšete třídy silného typu, které dědí typy z Durable SDK.
Metody rozšíření silného typu pro vyvolání dílčích orchestrací a aktivit Tyto metody rozšíření lze použít také z aktivit a orchestrací založených na funkcích.

Příklad založený na funkcích

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

Příklad založený na třídách

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

Odolné entity

Odolné entity jsou podporovány v izolovaném pracovním procesu .NET. Prohlédni si průvodce vývojářem.

Průvodce migrací

V této příručce se předpokládá, že začínáte s projektem .NET Durable Functions 2.x.

Aktualizace projektu

Prvním krokem je aktualizace projektu na izolovanou technologii Azure Functions .NET. Pak aktualizujte odkazy na balíčky NuGet Durable Functions.

Staré:

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

Nová:

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

Aktualizace kódu

Durable Functions pro izolovaný pracovní proces .NET je zcela nový balíček s různými typy a obory názvů. Výsledkem jsou požadované změny kódu, ale řada rozhraní API se zarovná bez nutnosti změn.

Schéma Host.json

Schéma pro izolovaný pracovní proces Durable Functions .NET a Durable Functions 2.x zůstalo stejné, žádné změny by neměly být potřeba.

Změny veřejného rozhraní API

Tato tabulka není vyčerpávajícím seznamem změn.

2.x	Izolovaný režim
`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>()` nebo vložte vstup jako parametr: `MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)`
`DurableActivityContext`	Žádný ekvivalent
`DurableActivityContext.GetInput<T>()`	Vložení vstupu jako parametru `MyActivity([ActivityTrigger] T input)`
`IDurableOrchestrationContext.CallActivityWithRetryAsync`	`TaskOrchestrationContext.CallActivityAsync`, zahrňte `TaskOptions` parametr s podrobnostmi o opakování.
`IDurableOrchestrationContext.CallSubOrchestratorWithRetryAsync`	`TaskOrchestrationContext.CallSubOrchestratorAsync`, zahrňte `TaskOptions` parametr s podrobnostmi o opakování.
`IDurableOrchestrationContext.CallHttpAsync`	`TaskOrchestrationContext.CallHttpAsync`
`IDurableOrchestrationContext.CreateReplaySafeLogger(ILogger)`	`TaskOrchestrationContext.CreateReplaySafeLogger<T>()` nebo `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`	Odebrání, přidání `FunctionContext` jako vstupního parametru
`IDurableEntityContext.HasState`	`TaskEntityOperation.State.HasState`
`IDurableEntityContext.BatchSize`	Odstraněno
`IDurableEntityContext.BatchPosition`	Odstraněno
`IDurableEntityContext.GetState`	`TaskEntityOperation.State.GetState`
`IDurableEntityContext.SetState`	`TaskEntityOperation.State.SetState`
`IDurableEntityContext.DeleteState`	`TaskEntityOperation.State.SetState(null)`
`IDurableEntityContext.GetInput`	`TaskEntityOperation.GetInput`
`IDurableEntityContext.Return`	Odstraněn. Místo toho se použila návratová hodnota metody.
`IDurableEntityContext.SignalEntity`	`TaskEntityContext.SignalEntity`
`IDurableEntityContext.StartNewOrchestration`	`TaskEntityContext.ScheduleNewOrchestration`
`IDurableEntityContext.DispatchAsync`	`TaskEntityDispatcher.DispatchAsync`. Parametry konstruktoru byly odebrány.
`IDurableOrchestrationClient.GetStatusAsync`	`DurableTaskClient.GetInstanceAsync`

Změny chování

Výchozí chování serializace se změnilo z Newtonsoft.Json na System.Text.Json. Další informace najdete tady.

Sdílet prostřednictvím