Dauerhafte Timer

Durable Functions stellt durable Timer für die Verwendung in Orchestratorfunktionen bereit, um Verzögerungen zu implementieren oder Timeouts für asynchrone Aktionen einzurichten. Verwenden Sie dauerhafte Zeitgeber in Orchestratorfunktionen anstelle von sleep- oder delay-APIs, die in die Sprache integriert werden können.

Dauerhafte Aufgaben-SDKs bieten dauerhafte Zeitgeber für die Verwendung in Orchestrierungen zum Implementieren von Verzögerungen oder zum Einrichten von Timeouts für asynchrone Aktionen. Verwenden Sie dauerhafte Zeitgeber in Orchestrierungen anstelle von APIs, die möglicherweise in die Sprache integriert sind, wie sleep oder delay.

Von Bedeutung

Derzeit ist das PowerShell Durable Task SDK nicht verfügbar.

Dauerhafte Timer sind Aufgaben, die mit der entsprechenden create timer API für die angegebene Sprache erstellt werden, wie in den folgenden Beispielen gezeigt. Sie nehmen entweder eine Fälligkeit oder eine Dauer als Argument an.

// Put the orchestrator to sleep for 72 hours
DateTime dueTime = context.CurrentUtcDateTime.AddHours(72);
await context.CreateTimer(dueTime, CancellationToken.None);

// Put the orchestrator to sleep for 72 hours
// Note that DateTime comes from the "luxon" module
const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ hours: 72 });
yield context.df.createTimer(deadline.toJSDate());

# Put the orchestrator to sleep for 72 hours
due_time = context.current_utc_datetime + timedelta(hours=72)
durable_timeout_task = context.create_timer(due_time)

# Put the orchestrator to sleep for 72 hours
$duration = New-TimeSpan -Hours 72
Start-DurableTimer -Duration $duration

// Put the orchestrator to sleep for 72 hours
ctx.createTimer(Duration.ofHours(72)).await();

// Put the orchestration to sleep for 72 hours
await context.CreateTimer(TimeSpan.FromHours(72), CancellationToken.None);

# Put the orchestration to sleep for 72 hours
from datetime import timedelta
yield ctx.create_timer(timedelta(hours=72))

// Put the orchestration to sleep for 72 hours
ctx.createTimer(Duration.ofHours(72)).await();

// Put the orchestration to sleep for 72 hours
yield ctx.createTimer(72 * 60 * 60);

Wenn Sie await die Timer-Aufgabe ausführen, schläft die Orchestrator-Funktion bis zur angegebenen Ablaufzeit.

Wenn Sie await die Timer-Aufgabe ausführen, schläft die Orchestrierung bis zur angegebenen Ablaufzeit.

Hinweis

Orchestrierungen verarbeiten weiterhin andere eingehende Ereignisse, während sie darauf warten, dass eine Timer-Aufgabe abläuft.

Timerbeschränkungen

Wenn Sie einen Timer erstellen, der um 14:30 Uhr UTC abläuft, wird im zugrunde liegenden Durable Task Framework eine Meldung eingequent, die nur um 1:30 Uhr UTC sichtbar wird. Wenn die Funktions-App in der Zwischenzeit auf Nullinstanzen skaliert wird, stellt die neu sichtbare Zeitgebermeldung sicher, dass die Funktions-App erneut auf einer entsprechenden VM aktiviert wird.

Hinweis

Für JavaScript-, Python- und PowerShell-Apps sind dauerhafte Zeitgeber auf sechs Tage begrenzt. Um diese Einschränkung zu umgehen, verwenden Sie die Timer-APIs in einer while Schleife, um eine längere Verzögerung zu simulieren. Aktuelle .NET- und Java-Apps unterstützen beliebig lange Zeitgeber.
Je nachdem, welche Version des SDK- und Speicheranbieters verwendet wird, können lange Zeitgeber von sechs Tagen oder mehr intern mithilfe einer Reihe kürzerer Zeitgeber (z. B. von dreiTägigen Dauer) implementiert werden, bis die gewünschte Ablaufzeit erreicht ist. Dieses Verhalten ist im zugrunde liegenden Datenspeicher feststellbar, wirkt sich jedoch nicht auf das Orchestrierungsverhalten aus.
Verwenden Sie keine integrierten Datums-/Uhrzeit-APIs, um die aktuelle Uhrzeit abzurufen. Wenn Sie ein Ablaufdatum für einen Timer in der Zukunft berechnen, verwenden Sie immer die aktuelle time-API der Orchestratorfunktion. Weitere Informationen finden Sie im Artikel Codeeinschränkungen für Orchestratorfunktionen.

Wenn Sie einen Timer erstellen, der um 14:30 Uhr UTC abläuft, wird im zugrunde liegenden Durable Task Framework eine Meldung eingequent, die nur um 1:30 Uhr UTC sichtbar wird. Die Timer-Nachricht stellt sicher, dass der Worker wieder aktiviert wird, wenn der Timer abläuft.

Hinweis

Die Angabe einer langen Verzögerung (z. B. eine Verzögerung von ein paar Tagen oder mehr) kann zur Erstellung mehrerer intern verwalteter dauerhafter Zeitgeber führen. Der Orchestrierungscode muss sich dieses Verhaltens nicht bewusst sein. Es kann jedoch in Frameworkprotokollen und dem gespeicherten Verlaufsstatus sichtbar sein.
Verwenden Sie keine integrierten Datums- und Uhrzeit-APIs, um die aktuelle Uhrzeit abzurufen. Verwenden Sie beim Berechnen eines zukünftigen Ablaufdatums für einen Timer immer die aktuelle Zeiteigenschaft des Orchestrierungskontexts (z. B. context.CurrentUtcDateTime in .NET, ctx.current_utc_datetime in Python oder ctx.currentUtcDateTime in JavaScript).

Nutzung bei Verzögerungen

Das folgende Beispiel zeigt, wie Sie dauerhafte Zeitgeber verwenden, um die Ausführung zu verzögern. Im Beispiel wird täglich eine Abrechnungsbenachrichtigung für 10 Tage ausgegeben.

[FunctionName("BillingIssuer")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    for (int i = 0; i < 10; i++)
    {
        DateTime deadline = context.CurrentUtcDateTime.Add(TimeSpan.FromDays(1));
        await context.CreateTimer(deadline, CancellationToken.None);
        await context.CallActivityAsync("SendBillingEvent");
    }
}

Hinweis

Im vorherigen C#-Beispiel wird auf Durable Functions 2.x abgezielt. Verwenden Sie für Durable Functions 1.x DurableOrchestrationContext anstelle von IDurableOrchestrationContext. Weitere Informationen zu den Unterschieden zwischen den Versionen finden Sie im Artikel Durable Functions versions.

const df = require("durable-functions");
const { DateTime } = require("luxon");

module.exports = df.orchestrator(function*(context) {
    for (let i = 0; i < 10; i++) {
        const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ days: 1 });
        yield context.df.createTimer(deadline.toJSDate());
        yield context.df.callActivity("SendBillingEvent");
    }
});

import azure.functions as func
import azure.durable_functions as df
from datetime import datetime, timedelta

def orchestrator_function(context: df.DurableOrchestrationContext):
    for i in range(0, 9):
        deadline = context.current_utc_datetime + timedelta(days=1)
        yield context.create_timer(deadline)
        yield context.call_activity("SendBillingEvent")

main = df.Orchestrator.create(orchestrator_function)

param($Context)

for ($num = 0 ; $num -le 9 ; $num++){
    $expiryTime = New-TimeSpan -Days 1
    $timerTask = Start-DurableTimer -Duration $expiryTime
    Invoke-DurableActivity -FunctionName 'SendBillingEvent'
}

@FunctionName("BillingIssuer")
public String billingIssuer(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    for (int i = 0; i < 10; i++) {
        ctx.createTimer(Duration.ofDays(1)).await();
        ctx.callActivity("SendBillingEvent").await();
    }
    return "done";
}

public class BillingIssuer : TaskOrchestrator<object?, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, object? input)
    {
        for (int i = 0; i < 10; i++)
        {
            await context.CreateTimer(TimeSpan.FromDays(1), CancellationToken.None);
            await context.CallActivityAsync("SendBillingEvent");
        }
        return "done";
    }
}

from datetime import timedelta
from durabletask import task

def send_billing_event(ctx: task.ActivityContext, _) -> None:
    # Send billing event
    pass

def billing_issuer(ctx: task.OrchestrationContext, _):
    for i in range(10):
        yield ctx.create_timer(timedelta(days=1))
        yield ctx.call_activity(send_billing_event)
    return "done"

public class BillingIssuer implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        for (int i = 0; i < 10; i++) {
            ctx.createTimer(Duration.ofDays(1)).await();
            ctx.callActivity("SendBillingEvent").await();
        }
        ctx.complete("done");
    }
}

import { ActivityContext, OrchestrationContext, TOrchestrator } from "@microsoft/durabletask-js";

const sendBillingEvent = async (_: ActivityContext): Promise<void> => {
    // Send billing event
};

const billingIssuer: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    for (let i = 0; i < 10; i++) {
        yield ctx.createTimer(24 * 60 * 60); // 1 day
        yield ctx.callActivity(sendBillingEvent);
    }
    return "done";
};

Warnung

Vermeiden Sie endlose Schleifen in Orchestratorfunktionen. Informationen zur sicheren und effizienten Implementierung von Endlosschleifenszenarien finden Sie unter Eternal Orchestrations.

Warnung

Vermeiden Sie endlose Schleifen in Orchestrierungen. Informationen zur sicheren und effizienten Implementierung von Endlosschleifenszenarien finden Sie unter Eternal Orchestrations.

Verwendung von Timeouts

In diesem Beispiel wird gezeigt, wie Sie dauerhafte Timer verwenden, um Timeouts zu implementieren:

[FunctionName("TryGetQuote")]
public static async Task<bool> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    TimeSpan timeout = TimeSpan.FromSeconds(30);
    DateTime deadline = context.CurrentUtcDateTime.Add(timeout);

    using (var cts = new CancellationTokenSource())
    {
        Task activityTask = context.CallActivityAsync("GetQuote");
        Task timeoutTask = context.CreateTimer(deadline, cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // success case
            cts.Cancel();
            return true;
        }
        else
        {
            // timeout case
            return false;
        }
    }
}

Hinweis

Das vorherige C#-Beispiel zielt auf Durable Functions 2.x ab. Verwenden Sie für Durable Functions 1.x DurableOrchestrationContext anstelle von IDurableOrchestrationContext. Weitere Informationen zu den Unterschieden zwischen den Versionen finden Sie im Artikel Durable Functions versions.

const df = require("durable-functions");
const { DateTime } = require("luxon");

module.exports = df.orchestrator(function*(context) {
    const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ seconds: 30 });

    const activityTask = context.df.callActivity("GetQuote");
    const timeoutTask = context.df.createTimer(deadline.toJSDate());

    const winner = yield context.df.Task.any([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        timeoutTask.cancel();
        return true;
    }
    else
    {
        // timeout case
        return false;
    }
});

import azure.functions as func
import azure.durable_functions as df
from datetime import datetime, timedelta

def orchestrator_function(context: df.DurableOrchestrationContext):
    deadline = context.current_utc_datetime + timedelta(seconds=30)
    activity_task = context.call_activity("GetQuote")
    timeout_task = context.create_timer(deadline)

    winner = yield context.task_any([activity_task, timeout_task])
    if winner == activity_task:
        timeout_task.cancel()
        return True
    elif winner == timeout_task:
        return False

main = df.Orchestrator.create(orchestrator_function)

param($Context)

$expiryTime =  New-TimeSpan -Seconds 30

$activityTask = Invoke-DurableActivity -FunctionName 'GetQuote' -NoWait
$timerTask = Start-DurableTimer -Duration $expiryTime -NoWait

$winner = Wait-DurableTask -Task @($activityTask, $timerTask) -Any

if ($winner -eq $activityTask) {
    Stop-DurableTimerTask -Task $timerTask
    return $True
}
else {
    return $False
}

@FunctionName("TryGetQuote")
public boolean tryGetQuote(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    Task<Double> activityTask = ctx.callActivity("GetQuote", Double.class);
    Task<Void> timerTask = ctx.createTimer(Duration.ofSeconds(30));

    Task<?> winner = ctx.anyOf(activityTask, timerTask);
    if (winner == activityTask) {
        // success case
        return true;
    } else {
        // timeout case
        return false;
    }
}

public class TryGetQuote : TaskOrchestrator<object?, bool>
{
    public override async Task<bool> RunAsync(TaskOrchestrationContext context, object? input)
    {
        using var cts = new CancellationTokenSource();

        Task<double> activityTask = context.CallActivityAsync<double>("GetQuote");
        Task timeoutTask = context.CreateTimer(TimeSpan.FromSeconds(30), cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // success case
            cts.Cancel();
            return true;
        }
        else
        {
            // timeout case
            return false;
        }
    }
}

from datetime import timedelta
from durabletask import task

def get_quote(ctx: task.ActivityContext, _) -> float:
    # Get quote logic
    return 100.0

def try_get_quote(ctx: task.OrchestrationContext, _):
    activity_task = ctx.call_activity(get_quote)
    timeout_task = ctx.create_timer(timedelta(seconds=30))

    winner = yield task.when_any([activity_task, timeout_task])
    if winner == activity_task:
        # success case
        return True
    else:
        # timeout case
        return False

public class TryGetQuote implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        Task<Double> activityTask = ctx.callActivity("GetQuote", Double.class);
        Task<Void> timerTask = ctx.createTimer(Duration.ofSeconds(30));

        Task<?> winner = ctx.anyOf(activityTask, timerTask).await();
        if (winner == activityTask) {
            // success case
            ctx.complete(true);
        } else {
            // timeout case
            ctx.complete(false);
        }
    }
}

import { ActivityContext, OrchestrationContext, TOrchestrator, whenAny } from "@microsoft/durabletask-js";

const getQuote = async (_: ActivityContext): Promise<number> => {
    // Get quote logic
    return 100.0;
};

const tryGetQuote: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const activityTask = ctx.callActivity(getQuote);
    const timeoutTask = ctx.createTimer(30);

    const winner = yield whenAny([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        return true;
    } else {
        // timeout case
        return false;
    }
};

Warnung

Brechen Sie in .NET, JavaScript, Python und PowerShell alle erstellten dauerhaften Timer ab, wenn Ihr Code nicht darauf wartet, dass sie abgeschlossen werden. In den vorherigen Beispielen erfahren Sie, wie ausstehende Timer abbrechen. Das Durable Task Framework ändert den Status einer Orchestrierung erst in „Abgeschlossen“, wenn alle ausstehenden Aufgaben abgeschlossen sind oder abgebrochen werden, einschließlich Aufgaben mit dauerhaften Timern.

Warnung

Falls Ihr SDK die Timer-Stornierung unterstützt (z. B. .NET), stornieren Sie alle erstellten dauerhaften Timer, wenn Ihr Code nicht auf deren Abschluss wartet. In den vorherigen Beispielen erfahren Sie, wie ausstehende Timer abbrechen. Das Durable Task Framework ändert den Status einer Orchestrierung erst in „Abgeschlossen“, wenn alle ausstehenden Aufgaben abgeschlossen sind oder abgebrochen werden, einschließlich Aufgaben mit dauerhaften Timern.

Dieser Abbruchmechanismus mit when-any-Muster beendet nicht die Ausführung von laufenden Aktivitätsfunktionen oder untergeordneten Orchestrierungen. Stattdessen kann die Orchestratorfunktion einfach das Ergebnis ignorieren und weitermachen. Wenn Ihre Funktions-App den Verbrauchsplan verwendet, werden Ihnen dennoch die verbrauchte Zeit und der Speicher der aufgegebenen Aktivitätsfunktion in Rechnung gestellt. Standardmäßig verfügen Funktionen, die im Verbrauchsplan ausgeführt werden, über einen Timeout von fünf Minuten. Wenn dieser Grenzwert überschritten wird, wird der Azure Functions Host neu gestartet, um die gesamte Ausführung zu beenden und eine unkontrollierte Abrechnungssituation zu verhindern. Das Funktionstimeout ist konfigurierbar.

Ein ausführlicheres Beispiel für die Implementierung von Timeouts in Orchestratorfunktionen finden Sie im Artikel "Menschliche Interaktion" .

Dieser Stornierungsmechanismus, der das when-any-Muster verwendet, beendet keine laufenden Aktivitäts- oder Unterorchestrierungsausführungen. Stattdessen lässt es einfach die Orchestrierung das Ergebnis ignorieren und weitergehen.

Nächste Schritte

Erfahren Sie, wie Sie externe Ereignisse auslösen und behandeln.

Erste Schritte mit Durable Task SDKs

Feedback

War diese Seite hilfreich?

Last updated on 2026-03-16

Freigeben über

Dauerhafte Timer

Timerbeschränkungen

Nutzung bei Verzögerungen

Verwendung von Timeouts

Nächste Schritte

Feedback

Zusätzliche Ressourcen