Panoramica di Durable Functions nel ruolo di lavoro isolato .NET

Articolo
11/16/2023

Questo articolo offre una panoramica di Durable Functions nel ruolo di lavoro isolato .NET. Il ruolo di lavoro isolato consente l'esecuzione dell'app Durable Functions in una versione .NET diversa da quella dell'host Funzioni di Azure.

Perché usare Durable Functions nel ruolo di lavoro isolato .NET?

L'uso di questo modello consente di ottenere tutti i vantaggi offerti dal processo di lavoro isolato .NET Funzioni di Azure. Per altre informazioni, vedere Vantaggi del modello di lavoro isolato. Inoltre, questo nuovo SDK include alcune nuove funzionalità.

Miglioramenti delle funzionalità rispetto a Durable Functions in-process

L'input di orchestrazione può essere inserito direttamente: MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)
Supporto per chiamate fortemente tipate e attività e orchestrazioni basate su classi (NOTA: in anteprima. Per altre informazioni, vedere qui.
Oltre a tutti i vantaggi del ruolo di lavoro isolato .NET Funzioni di Azure.

Generatore di origine e attività basate su classi e orchestrazioni

Requisito: aggiungere <PackageReference Include="Microsoft.DurableTask.Generators" Version="1.0.0-preview.1" /> al progetto.

Aggiungendo il pacchetto del generatore di origine, si ottiene l'accesso a due nuove funzionalità:

Attività e orchestrazioni basate su classi, un modo alternativo per scrivere Durable Functions. Invece di "basato su funzione", si scrivono classi fortemente tipate, che ereditano tipi da Durable SDK.
Metodi di estensione fortemente tipizzato per richiamare sotto orchestrazioni e attività. Questi metodi di estensione possono essere usati anche da attività e orchestrazioni basate su funzioni.

Esempio basato su funzione

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

Esempio basato su classi

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

Entità durevoli

Le entità durevoli sono supportate nel ruolo di lavoro isolato .NET. Vedere la guida per gli sviluppatori.

Guida alla migrazione

Questa guida presuppone che si inizi con un progetto .NET Durable Functions 2.x.

Aggiornare il progetto

Il primo passaggio consiste nell'aggiornare il progetto in modo che Funzioni di Azure isolato .NET. Aggiornare quindi i riferimenti al pacchetto NuGet di Durable Functions.

Vecchio:

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

Nuovo:

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

Aggiornare il codice

Durable Functions per il ruolo di lavoro isolato .NET è un pacchetto completamente nuovo con tipi e spazi dei nomi diversi. Di conseguenza, sono necessarie modifiche al codice, ma molte delle API si allineano senza modifiche necessarie.

Schema Host.json

Lo schema per i ruoli di lavoro isolati di Durable Functions .NET e Durable Functions 2.x è rimasto invariato, non è necessario apportare modifiche.

Modifiche all'API pubblica

Questa tabella non è un elenco completo delle modifiche.

2.x	Isolato
`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>()` o inserire l'input come parametro: `MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context, T input)`
`DurableActivityContext`	Nessun equivalente
`DurableActivityContext.GetInput<T>()`	Inserire l'input come parametro `MyActivity([ActivityTrigger] T input)`
`IDurableOrchestrationContext.CallActivityWithRetryAsync`	`TaskOrchestrationContext.CallActivityAsync`, includere `TaskOptions` il parametro con i dettagli dei tentativi.
`IDurableOrchestrationContext.CallSubOrchestratorWithRetryAsync`	`TaskOrchestrationContext.CallSubOrchestratorAsync`, includere `TaskOptions` il parametro con i dettagli dei tentativi.
`IDurableOrchestrationContext.CallHttpAsync`	`TaskOrchestrationContext.CallHttpAsync`
`IDurableOrchestrationContext.CreateReplaySafeLogger(ILogger)`	`TaskOrchestrationContext.CreateReplaySafeLogger<T>()` oppure `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`	Rimosso, aggiungere `FunctionContext` come parametro di input
`IDurableEntityContext.HasState`	`TaskEntityOperation.State.HasState`
`IDurableEntityContext.BatchSize`	Rimosse
`IDurableEntityContext.BatchPosition`	Rimosse
`IDurableEntityContext.GetState`	`TaskEntityOperation.State.GetState`
`IDurableEntityContext.SetState`	`TaskEntityOperation.State.SetState`
`IDurableEntityContext.DeleteState`	`TaskEntityOperation.State.SetState(null)`
`IDurableEntityContext.GetInput`	`TaskEntityOperation.GetInput`
`IDurableEntityContext.Return`	Rimosso. Valore restituito del metodo utilizzato.
`IDurableEntityContext.SignalEntity`	`TaskEntityContext.SignalEntity`
`IDurableEntityContext.StartNewOrchestration`	`TaskEntityContext.ScheduleNewOrchestration`
`IDurableEntityContext.DispatchAsync`	`TaskEntityDispatcher.DispatchAsync`. Parametri del costruttore rimossi.
`IDurableOrchestrationClient.GetStatusAsync`	`DurableTaskClient.GetInstanceAsync`

Modifiche comportamentali

Il comportamento predefinito della serializzazione è stato modificato da Newtonsoft.Json a System.Text.Json. Per ulteriori informazioni, vedi qui.

Condividi tramite