Cara menggunakan stop timer javascript

// 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[];

[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"];
    }
}

Catatan

Contoh C# sebelumnya menargetkan Durable Functions 2.x. Untuk Durable Functions 1.x, Anda harus menggunakan DurableOrchestrationContext alih-alih IDurableOrchestrationContext. Untuk informasi selengkapnya tentang perbedaan antara versi, lihat artikel Versi Durable Functions.

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 = "runtimeState"] String runtimeState] {
        return OrchestrationRunner.loadAndRun[runtimeState, ctx -> {
            for [int i = 0; i < 10; i++] {
                ctx.createTimer[Duration.ofDays[1]].await[];
                ctx.callActivity["SendBillingEvent"].await[];
            }
            return "done";
        }];
}

[FunctionName["TryGetQuote"]]
public static async Task 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;
        }
    }
}

Catatan

Contoh C# sebelumnya menargetkan Durable Functions 2.x. Untuk Durable Functions 1.x, Anda harus menggunakan DurableOrchestrationContext alih-alih IDurableOrchestrationContext. Untuk informasi selengkapnya tentang perbedaan antara versi, lihat artikel Versi Durable Functions.

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 String tryGetQuote[
    @DurableOrchestrationTrigger[name = "runtimeState"] String runtimeState] {
        return OrchestrationRunner.loadAndRun[runtimeState, ctx -> {
            Task activityTask = ctx.callActivity["GetQuote"];
            Task timerTask = ctx.createTimer[Duration.ofSeconds[30]];

            Task winner = ctx.anyOf[activityTask, timerTask];
            if [winner == activityTask] {
                // success case
                return true;
            } else {
                // timeout case
                return false;
            }
        }];
}