نمط التفاعل البشري

نمط التفاعل البشري يصف سير العمل الذي يتوقف وينتظر مدخلات الشخص قبل أن يستمر. هذا النمط مفيد لسير عمل الموافقة، والمصادقة متعددة العوامل، وأي سيناريو يستجيب فيه الشخص خلال فترة زمنية محددة.

على مستوى عام، يعمل النمط كما يلي:

1. يقوم المنسق بالاتصال بنشاط لإبلاغ شخص (إرسال رمز SMS، أو إرسال بريد إلكتروني للمضيف، وهكذا).
2. يبدأ المنسق مؤقتا مدوما وينتظر في الوقت نفسه حدثا خارجيا من الشخص.
3. إذا استجاب الشخص قبل أن ينطلق المؤقت، يقوم المنسق بمعالجة الرد.
4. إذا أطلق المؤقت أولا، يتولى المنسق المهلة (على سبيل المثال، برفض الطلب).

في هذه المقالة:

• نظرة عامة على سيناريو التفاعل البشري - لماذا هذا النمط مهم
• تعريف المنسق - تنفيذ سباق المؤقت مقابل الحدث
• تعريف الأنشطة - إرسال الإشعارات ومعالجة النتائج
• تشغيل عينة التفاعل البشري - اختبر سير العمل من البداية إلى النهاية

ملحوظة

تظهر محاور حزمة تطوير المهام المتطورة Durable Functions وDurable Task نفس النمط مع سيناريوهات مختلفة: Durable Functions تستخدم مثال التحقق من الهاتف SMS، بينما تستخدم مجموعات تطوير المهام المتطورة مثال سير عمل موافقة.

توضح هذه العينة كيفية بناء تنسيق Durable Functions يشمل التفاعل البشري. يطبق المثال نظام تحقق هاتفي قائم على الرسائل النصية النصية. هذا شائع في التحقق من رقم الهاتف وتدفقات التحقق من العوامل متعددة العوامل (MFA).

ملحوظة

تتوفر عينات كاملة من الكود للغات C# وJavaScript وPython. عينات PowerShell و Java غير متوفرة حاليا.

ملحوظة

الإصدار الرابع من نموذج البرمجة Node.js ل دالات Azure متوفر بشكل عام. تم تصميم نموذج v4 لتوفير تجربة أكثر مرونة وسهولة لمطوري JavaScript وTypeScript. لمزيد من المعلومات حول الفروقات بين v3 و v4، راجع دليل الهجرة.

في مقتطفات الكود التالية، تشير جافاسكريبت (PM4) إلى نموذج البرمجة v4، وهو التجربة الجديدة.

المتطلبات المسبقه

C#‎

• إكمال مقالة التشغيل السريع
• قم باستنساخ أو تحميل مشروع العينات من GitHub
  • عينات النماذج المعزولة
  • عينات النموذج قيد العملية

JavaScript

نموذج البرمجة V3

• إكمال مقالة التشغيل السريع
• Clone أو قم بتحميل مشروع العينات من GitHub

نموذج البرمجة V4

• إكمال مقالة التشغيل السريع
• Clone أو قم بتحميل مشروع العينات من GitHub

Python

• إكمال مقالة التشغيل السريع
• Clone أو قم بتحميل مشروع العينات من GitHub

بوويرشيل

• إكمال مقالة التشغيل السريع
• Clone أو قم بتحميل مشروع العينات من GitHub

Java

• إكمال مقالة التشغيل السريع

توضح هذه المقالة كيفية تنفيذ نمط التفاعل البشري باستخدام مجموعات تطوير المهام الدائمة. ينفذ المثال سير عمل موافقة حيث ينتظر التنسيق حتى يوافق أو يرفض الشخص على طلب قبل أن يستمر.

نظرة عامة على سيناريو التفاعل البشري

التحقق عبر الهاتف يساعد في التأكد من أن الأشخاص الذين يستخدمون تطبيقك ليسوا مرسلين مزعجين وأنهم يتحكمون في رقم الهاتف الذي يقدمونه. المصادقة متعددة العوامل هي طريقة شائعة لحماية الحسابات. بناء التحقق الخاص من هاتفك يتطلب تفاعلا مع شخص بحالة محددة. عادة ما يحصل المستخدم على رمز (على سبيل المثال، رقم مكون من أربعة أرقام) ويجب عليه الرد في وقت معقول.

دالات Azure القياسية هي بدون حالة (مثل العديد من نقاط النهاية السحابية الأخرى)، لذا يتطلب هذا النوع من التفاعل تخزين الحالة في قاعدة بيانات أو مخزن دائم آخر. كما أنك تقسم التفاعل بين عدة وظائف وتنسقها. على سبيل المثال، تقوم إحدى الوظائف بإنشاء رمز، وتخزينه، وإرساله إلى هاتف المستخدم. تستقبل دالة أخرى رد المستخدم وتربط الطلب الأصلي للتحقق من صحة الرمز. أضف مهلة توقف للمساعدة في حماية الأمن. هذا السير يصبح معقدا بسرعة.

يقلل Durable Functions من تعقيد هذا السيناريو. في هذه العينة، تدير دالة المنسق التفاعل الحالة دون وجود مخزن بيانات خارجي. نظرا لأن وظائف الأوركستراتور متينة، فإن هذه التدفقات التفاعلية موثوقة للغاية.

تعد سير العمل للموافقة شائعة في تطبيقات الأعمال حيث يجب مراجعة الطلب من قبل شخص قبل المتابعة. متطلبات سير العمل هي:

• انتظر إلى أجل غير مسمى رد فعل بشري، أو حتى انتهاء الوقت
• التعامل مع نتائج الموافقة والرفض معا
• الدعم يتوقف عند عدم تلقي أي رد
• تتبع الحالة حتى يتمكن الطالب من التحقق من التقدم

تبسط مجموعات تطوير المهام المتطورة هذا السيناريو ب:

• الأحداث الخارجية: يمكن للتنسيق التنسيقي التوقف والانتظار لحدث يثاره نظام أو مستخدم خارجي
• مؤقتات متينة: اضبط مهلة توقف تعمل إذا لم يتم استقبال أي رد
• الحالة المخصصة: تتبع وعرض حالة سير العمل الحالية للعملاء

تكوين تكامل Twilio

تتضمن هذه العينة استخدام خدمة Twilio من أجل إرسال رسائل SMS إلى هاتف جوال. دالات Azure يدعم بالفعل Twilio عبر Twilio binding، وتستخدم العينة هذه الميزة.

أول شيء بحاجة إليه هو حساب Twilio. يُصبح بإمكانك إنشاء حساب مجاني في https://www.twilio.com/try-twilio. بمجرد أن يكون لديك حساب، قم بإضافةإعدادات التطبيق الثلاثة التالية إلى تطبيق الوظائف.

اسم إعداد التطبيق	وصف القيمة
TwilioAccountSid	معرّف الأمان فيما يتعلق بحساب Twilio الخاص بك
TwilioAuthToken	رمز المصادقة المُميز لحساب Twilio الخاص بك
TwilioPhoneNumber	رقم الهاتف المرتبط بحسابك على Twilio. يُستخدم هذا لإرسال رسائل SMS.

تعريف الموزع

وظيفة المنسق E4_SmsPhoneVerification

C#‎

نموذج العامل المعزول

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;

public static partial class PhoneVerification
{
    [Function("E4_SmsPhoneVerification")]
    public static async Task<bool> Run(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        string phoneNumber = context.GetInput<string>()
            ?? throw new ArgumentNullException(
                nameof(phoneNumber),
                "A phone number input is required.");

        int challengeCode = await context.CallActivityAsync<int>(
            "E4_SendSmsChallenge",
            phoneNumber);

        using var timeoutCts = new CancellationTokenSource();

        // The user has 90 seconds to respond with the code they received.
        DateTime expiration = context.CurrentUtcDateTime.AddSeconds(90);
        Task timeoutTask = context.CreateTimer(expiration, timeoutCts.Token);

        bool authorized = false;
        for (int retryCount = 0; retryCount <= 3; retryCount++)
        {
            Task<int> challengeResponseTask =
                context.WaitForExternalEvent<int>("SmsChallengeResponse");

            Task winner = await Task.WhenAny(challengeResponseTask, timeoutTask);
            if (winner == challengeResponseTask)
            {
                if (challengeResponseTask.Result == challengeCode)
                {
                    authorized = true;
                    break;
                }
            }
            else
            {
                break;
            }
        }

        if (!timeoutTask.IsCompleted)
        {
            // All pending timers must complete or be canceled before the function exits.
            timeoutCts.Cancel();
        }

        return authorized;
    }
}

ملحوظة

هذا المنظم حتمي لأنه CurrentUtcDateTime يعيد نفس القيمة في نفس النقطة في كل إعادة تشغيل. يضمن هذا السلوك أن يكون winner ذلك نفسه لكل استدعاء متكرر ل Task.WhenAny.

النموذج أثناء العملية

[FunctionName("E4_SmsPhoneVerification")]
public static async Task<bool> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string phoneNumber = context.GetInput<string>();
    if (string.IsNullOrEmpty(phoneNumber))
    {
        throw new ArgumentNullException(
            nameof(phoneNumber),
            "A phone number input is required.");
    }

    int challengeCode = await context.CallActivityAsync<int>(
        "E4_SendSmsChallenge",
        phoneNumber);

    using (var timeoutCts = new CancellationTokenSource())
    {
        // The user has 90 seconds to respond with the code they received in the SMS message.
        DateTime expiration = context.CurrentUtcDateTime.AddSeconds(90);
        Task timeoutTask = context.CreateTimer(expiration, timeoutCts.Token);

        bool authorized = false;
        for (int retryCount = 0; retryCount <= 3; retryCount++)
        {
            Task<int> challengeResponseTask =
                context.WaitForExternalEvent<int>("SmsChallengeResponse");

            Task winner = await Task.WhenAny(challengeResponseTask, timeoutTask);
            if (winner == challengeResponseTask)
            {
                // We got back a response! Compare it to the challenge code.
                if (challengeResponseTask.Result == challengeCode)
                {
                    authorized = true;
                    break;
                }
            }
            else
            {
                // Timeout expired
                break;
            }
        }

        if (!timeoutTask.IsCompleted)
        {
            // All pending timers must be complete or canceled before the function exits.
            timeoutCts.Cancel();
        }

        return authorized;
    }
}

ملحوظة

قد لا يكون واضحا في البداية، لكن هذا الموزع لا ينتهك قيد التوزيع الحتمي. هي حتمية لأن الخاصية CurrentUtcDateTime تحسب وقت انتهاء صلاحية المؤقت، وتعيد نفس القيمة في كل إعادة تشغيل في هذه المرحلة من كود الأوركستراتور. يضمن هذا السلوك أن يكون winner ذلك نفسه لكل استدعاء متكرر ل Task.WhenAny.

JavaScript

نموذج البرمجة V3

الوظيفة E4_SmsPhoneVerification تستخدم function.json القياسية لوظائف المنسق.

{
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

إليك التعليمات البرمجية التي تنفذ الدالة:

const df = require("durable-functions");
const moment = require("moment");

module.exports = df.orchestrator(function* (context) {
    const phoneNumber = context.df.getInput();
    if (!phoneNumber) {
        throw "A phone number input is required.";
    }

    const challengeCode = yield context.df.callActivity("E4_SendSmsChallenge", phoneNumber);

    // The user has 90 seconds to respond with the code they received in the SMS message.
    const expiration = moment.utc(context.df.currentUtcDateTime).add(90, "s");
    const timeoutTask = context.df.createTimer(expiration.toDate());

    let authorized = false;
    for (let i = 0; i <= 3; i++) {
        const challengeResponseTask = context.df.waitForExternalEvent("SmsChallengeResponse");

        const winner = yield context.df.Task.any([challengeResponseTask, timeoutTask]);

        if (winner === challengeResponseTask) {
            // We got back a response! Compare it to the challenge code.
            if (challengeResponseTask.result === challengeCode) {
                authorized = true;
                break;
            }
        } else {
            // Timeout expired
            break;
        }
    }

    if (!timeoutTask.isCompleted) {
        // All pending timers must be complete or canceled before the function exits.
        timeoutTask.cancel();
    }

    return authorized;
});

ملحوظة

قد لا يكون واضحا في البداية، لكن هذا الموزع لا ينتهك قيد التوزيع الحتمي. هي حتمية لأن الخاصية currentUtcDateTime تحسب وقت انتهاء صلاحية المؤقت، وتعيد نفس القيمة في كل إعادة تشغيل في هذه المرحلة من كود الأوركستراتور. يضمن هذا السلوك أن يكون winner ذلك نفسه لكل استدعاء متكرر ل context.df.Task.any.

نموذج البرمجة V4

إليك الكود الذي ينفذ smsPhoneVerification وظيفة التوزيع الموسيقي:

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

const sendSmsChallengeActivityName = "sendSmsChallenge";

df.app.orchestration("smsPhoneVerification", function* (context) {
    const phoneNumber = context.df.getInput();
    if (!phoneNumber) {
        throw new Error("A phone number input is required.");
    }

    const challengeCode = yield context.df.callActivity(sendSmsChallengeActivityName, phoneNumber);

    // The user has 90 seconds to respond with the code they received in the SMS message.
    const expiration = DateTime.fromJSDate(context.df.currentUtcDateTime).plus({ seconds: 90 });
    const timeoutTask = context.df.createTimer(expiration.toJSDate());

    let authorized = false;
    for (let i = 0; i <= 3; i++) {
        const challengeResponseTask = context.df.waitForExternalEvent("SmsChallengeResponse");

        const winner = yield context.df.Task.any([challengeResponseTask, timeoutTask]);

        if (winner === timeoutTask) {
            // Timeout expired
            break;
        }

        // We got back a response! Compare it to the challenge code.
        if (challengeResponseTask.result === challengeCode) {
            authorized = true;
            break;
        }
    }

    if (!timeoutTask.isCompleted) {
        // All pending timers must be complete or canceled before the function exits.
        timeoutTask.cancel();
    }

    return authorized;
});

Python

الوظيفة E4_SmsPhoneVerification تستخدم function.json القياسية لوظائف المنسق.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ]
}

إليك التعليمات البرمجية التي تنفذ الدالة:

import azure.durable_functions as df
from datetime import timedelta

def is_valid_phone_number(phone_number: str):
    has_area_code = phone_number[0] == "+"
    is_positive_num = phone_number[1:].isdigit()
    return has_area_code and is_positive_num

def orchestrator_function(context: df.DurableOrchestrationContext):

    phone_number = context.get_input()

    if (not phone_number) or (not is_valid_phone_number(phone_number)):
        msg = "Please provide a phone number beginning with an international dialing prefix"+\
            "(+) followed by the country code, and then rest of the phone number. Example:"\
            "'+1425XXXXXXX'"
        raise Exception(msg)

    challenge_code = yield context.call_activity("SendSMSChallenge", phone_number)

    expiration = context.current_utc_datetime + timedelta(seconds=180)
    timeout_task = context.create_timer(expiration)

    authorized = False
    for _ in range(3):
        challenge_response_task = context.wait_for_external_event("SmsChallengeResponse")
        winner = yield context.task_any([challenge_response_task, timeout_task])

        if (winner == challenge_response_task):
            # We got back a response! Compare it to the challenge code
            if (challenge_response_task.result == challenge_code):
                authorized = True
                break
        else:
            # Timeout expired
            break
    
    if not timeout_task.is_completed:
        # All pending timers must be complete or canceled before the function exits.
        timeout_task.cancel()

    return authorized

main = df.Orchestrator.create(orchestrator_function)

ملحوظة

قد لا يكون واضحا في البداية، لكن هذا الموزع لا ينتهك قيد التوزيع الحتمي. هذا حتمي لأن الخاصية currentUtcDateTime تحسب وقت انتهاء صلاحية المؤقت وتعيد نفس القيمة في كل إعادة تشغيل في هذه المرحلة من كود الأوركستراتور. يضمن هذا السلوك أن كل استدعاء متكرر إلى context.df.Task.any يؤدي إلى نفس winner.

بوويرشيل

يرسل المنسق رمز تحدي عبر الرسائل النصية وينتظر رد المستخدم. يسمح بثلاث محاولات تصل إلى نافذة استراحة مدتها 90 ثانية.

param($Context)

$phoneNumber = $Context.Input

# Step 1: Send the SMS challenge code
$challengeCode = Invoke-DurableActivity -FunctionName 'E4_SendSmsChallenge' -Input $phoneNumber

# Step 2: Wait for the user to respond with the code
# Allow up to three attempts within a 90-second timeout window
$authorized = $false
$timeoutTask = Start-DurableTimer -Duration (New-TimeSpan -Seconds 90) -NoWait

for ($retryCount = 0; $retryCount -lt 3; $retryCount++) {
    $challengeResponseTask = Start-DurableExternalEventListener -EventName 'SmsChallengeResponse' -NoWait
    $winner = Wait-DurableTask -Task @($challengeResponseTask, $timeoutTask) -Any

    if ($winner -eq $timeoutTask) {
        break
    }

    $response = Get-DurableTaskResult -Task $challengeResponseTask
    if ($response -eq $challengeCode) {
        $authorized = $true
        break
    }
}

# Cancel the timeout timer if the user was verified before it fired
if ($authorized) {
    Stop-DurableTimerTask -Task $timeoutTask
}

$authorized

Java

@FunctionName("E4_SmsPhoneVerification")
public boolean smsPhoneVerification(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String phoneNumber = ctx.getInput(String.class);

    // Step 1: Send the SMS challenge code
    int challengeCode = ctx.callActivity(
            "E4_SendSmsChallenge", phoneNumber, Integer.class).await();

    // Step 2: Create a 90-second timeout timer
    Duration timeout = Duration.ofSeconds(90);

    // Step 3: Wait for the user to respond with the code
    // Allow up to three attempts within the timeout window
    boolean authorized = false;
    Task<Void> timeoutTask = ctx.createTimer(timeout);

    for (int retryCount = 0; retryCount < 3; retryCount++) {
        Task<String> challengeResponseTask = ctx.waitForExternalEvent(
                "SmsChallengeResponse", String.class);

        Task<?> winner = ctx.anyOf(challengeResponseTask, timeoutTask).await();

        if (winner == challengeResponseTask) {
            String response = challengeResponseTask.await();
            if (Integer.parseInt(response) == challengeCode) {
                authorized = true;
                break;
            }
        } else {
            // Timeout expired
            break;
        }
    }

    return authorized;
}

ملحوظة

هذا المنظم حتمي لأنه ctx.createTimerctx.waitForExternalEvent ينتج نفس النتائج في كل إعادة تشغيل.

بمجرد التشغيل، تقوم وظيفة التنسيق هذه بالخطوات التالية:

1. يحصل على رقم هاتف لإرسال إشعار الرسائل النصية إليه.
2. يتصل E4_SendSmsChallenge لإرسال رسالة SMS للمستخدم ويعيد رمز التحدي المتوقع المكون من أربعة أرقام.
3. ينشئ مؤقتا متين يعمل بعد 90 ثانية من الوقت الحالي.
4. بالتوازي مع المؤقت، ينتظر حدث SmsChallengeResponse من المستخدم.

يتلقى المستخدم رسالة SMS مع رمز من أربعة أرقام. لديهم 90 ثانية لإرسال نفس الكود إلى مثيل المنسق لإكمال التحقق. إذا قدموا كودا خاطئا، يحصلون على ثلاث محاولات إضافية خلال نفس نافذة ال 90 ثانية.

التحذير

ألغ المؤقتات التي لم تعد بحاجة إليها. في المثال السابق، يقوم التوزيع الموسيقي بإلغاء المؤقت عند قبول استجابة التحدي.

يقدم المنسق طلب موافقة، ثم ينتظر إما رد بشري أو وقت مستقطع.

C#‎

using Microsoft.DurableTask;
using System;
using System.Threading;
using System.Threading.Tasks;

[DurableTask(nameof(ApprovalOrchestration))]
public class ApprovalOrchestration : TaskOrchestrator<ApprovalRequestData, ApprovalResult>
{
    public override async Task<ApprovalResult> RunAsync(
        TaskOrchestrationContext context, ApprovalRequestData input)
    {
        string requestId = input.RequestId;
        double timeoutHours = input.TimeoutHours;

        // Step 1: Submit the approval request (notify approver)
        SubmissionResult submissionResult = await context.CallActivityAsync<SubmissionResult>(
            nameof(SubmitApprovalRequestActivity), input);

        // Make the status available via custom status
        context.SetCustomStatus(submissionResult);

        // Step 2: Create a durable timer for the timeout
        DateTime timeoutDeadline = context.CurrentUtcDateTime.AddHours(timeoutHours);

        using var timeoutCts = new CancellationTokenSource();
        Task timeoutTask = context.CreateTimer(timeoutDeadline, timeoutCts.Token);

        // Step 3: Wait for an external event (approval/rejection)
        Task<ApprovalResponseData> approvalTask = context.WaitForExternalEvent<ApprovalResponseData>(
            "approval_response");

        // Step 4: Wait for either the timeout or the approval response
        Task completedTask = await Task.WhenAny(approvalTask, timeoutTask);

        // Step 5: Process based on which task completed
        ApprovalResult result;

        if (completedTask == approvalTask)
        {
            // Human responded in time - cancel the timeout timer
            timeoutCts.Cancel();

            ApprovalResponseData approvalData = approvalTask.Result;

            // Process the approval
            result = await context.CallActivityAsync<ApprovalResult>(
                nameof(ProcessApprovalActivity),
                new ProcessApprovalInput
                {
                    RequestId = requestId,
                    IsApproved = approvalData.IsApproved,
                    Approver = approvalData.Approver
                });
        }
        else
        {
            // Timeout occurred
            result = new ApprovalResult
            {
                RequestId = requestId,
                Status = "Timeout",
                ProcessedAt = context.CurrentUtcDateTime.ToString("o")
            };
        }

        return result;
    }
}

JavaScript

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

const approvalOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext,
  amount: number
): any {
  // Step 1: Submit the request
  const requestId: string = yield ctx.callActivity(submitRequest, { amount });

  ctx.setCustomStatus({ stage: "Awaiting approval", requestId });

  // Step 2: Race external event vs timer
  const approvalEvent = ctx.waitForExternalEvent<{ approved: boolean }>(
    "approval"
  );
  const timeout = ctx.createTimer(5); // 5-second timeout

  const winner = yield whenAny([approvalEvent, timeout]);

  let result: string;
  if (winner === approvalEvent) {
    // Human responded in time
    const decision = approvalEvent.getResult();
    ctx.setCustomStatus({
      stage: "Processing",
      requestId,
      approved: decision.approved,
    });
    result = yield ctx.callActivity(processApproval, {
      requestId,
      approved: decision.approved,
    });
  } else {
    // Timer fired first — timed out
    ctx.setCustomStatus({ stage: "Timed out", requestId });
    result = yield ctx.callActivity(notifyTimeout, requestId);
  }

  ctx.setCustomStatus({ stage: "Completed", requestId });
  return result;
};

Python

import datetime
from durabletask import task

def human_interaction_orchestrator(ctx: task.OrchestrationContext, input_data: dict) -> dict:
    """
    Orchestrator that demonstrates the human interaction pattern.

    Submits an approval request, then waits for a human to approve or reject.
    """
    request_id = input_data.get("request_id")
    timeout_hours = input_data.get("timeout_hours", 24)

    # Step 1: Submit the approval request (notify approver)
    request_data = {
        "request_id": request_id,
        "requester": input_data.get("requester"),
        "item": input_data.get("item")
    }

    submission_result = yield ctx.call_activity("submit_approval_request", input=request_data)

    # Make the status available via custom status
    ctx.set_custom_status(submission_result)

    # Step 2: Create a durable timer for the timeout
    timeout_deadline = ctx.current_utc_datetime + datetime.timedelta(hours=timeout_hours)
    timeout_task = ctx.create_timer(timeout_deadline)

    # Step 3: Wait for an external event (approval/rejection)
    approval_task = ctx.wait_for_external_event("approval_response")

    # Step 4: Wait for either the timeout or the approval response
    winner_task = yield task.when_any([approval_task, timeout_task])

    # Step 5: Process based on which task completed
    if winner_task == approval_task:
        # Human responded in time
        approval_data = yield approval_task

        # Process the approval
        result = yield ctx.call_activity("process_approval", input={
            "request_id": request_id,
            "is_approved": approval_data.get("is_approved", False),
            "approver": approval_data.get("approver", "Unknown")
        })
    else:
        # Timeout occurred
        result = {
            "request_id": request_id,
            "status": "Timeout",
            "timed_out_at": ctx.current_utc_datetime.isoformat()
        }

    return result

بوويرشيل

تم عرض هذه العينة لأنظمة .NET وJavaScript وJava وPython.

Java

import com.microsoft.durabletask.*;
import com.microsoft.durabletask.azuremanaged.DurableTaskSchedulerWorkerExtensions;
import java.time.Duration;

DurableTaskGrpcWorker worker = DurableTaskSchedulerWorkerExtensions.createWorkerBuilder(connectionString)
    .addOrchestration(new TaskOrchestrationFactory() {
        @Override
        public String getName() { return "ApprovalWorkflow"; }

        @Override
        public TaskOrchestration create() {
            return ctx -> {
                // Get the approval request
                ApprovalRequest request = ctx.getInput(ApprovalRequest.class);

                // Set initial status
                ctx.setCustomStatus(new WorkflowStatus("Waiting for approval", null));

                // Create a timeout timer
                Task timeoutTask = ctx.createTimer(
                    Duration.ofHours((long) request.timeoutHours));

                // Wait for external event (approval response)
                Task<ApprovalResponse> approvalTask = ctx.waitForExternalEvent(
                    "approval_response", ApprovalResponse.class);

                // Wait for either approval or timeout
                Task<?> winner = ctx.anyOf(approvalTask, timeoutTask).await();

                if (winner == approvalTask) {
                    // Human responded in time
                    ApprovalResponse response = approvalTask.await();
                    String status = response.isApproved ? "APPROVED" : "REJECTED";
                    ctx.setCustomStatus(new WorkflowStatus(status, response));
                    ctx.complete(new WorkflowResult(
                        status,
                        response.isApproved ? "Request approved" : "Request rejected"));
                } else {
                    // Timeout occurred
                    ctx.setCustomStatus(new WorkflowStatus("Timed out", null));
                    ctx.complete(new WorkflowResult("TIMEOUT", "Request timed out"));
                }
            };
        }
    })
    .build();

يقوم هذا الموزع بأداء الأفعال التالية:

1. يقدم طلب الموافقة عن طريق استدعاء نشاط يخطر المعترض.
2. يضبط الحالة المخصصة حتى يتمكن العملاء من تتبع التقدم.
3. ينشئ مؤقتا متيما لموعد انتهاء المهلة.
4. ينتظر حدثا خارجيا (approval_response) يطرحه المعترف.
5. يستخدم WhenAny، when_any، أو anyOf الانتظار لما يكتمل أولا: الموافقة أو المهلة.
6. يعالج النتيجة بناء على المهمة التي تكملها.

التحذير

ألغ المؤقتات التي لم تعد بحاجة إليها. في مثال C#، يقوم التوزيع الموسيقي بإلغاء مؤقت المهلة عند حصوله على الموافقة.

تعريف الأنشطة

وظيفة نشاط E4_SendSmsChallenge

ترسل وظيفة E4_SendSmsChallenge رسالة SMS تتضمن رمزا مكون من أربعة أرقام إلى المستخدم.

C#‎

نموذج العامل المعزول

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;

public static partial class PhoneVerification
{
    [Function("E4_SendSmsChallenge")]
    public static async Task<int> SendSmsChallenge(
        [ActivityTrigger] string phoneNumber,
        FunctionContext executionContext)
    {
        ILogger logger = executionContext.GetLogger("E4_SendSmsChallenge");

        int challengeCode = Random.Shared.Next(10000);
        logger.LogInformation(
            "Sending verification code {ChallengeCode:0000} to {PhoneNumber}.",
            challengeCode,
            phoneNumber);

        string accountSid = Environment.GetEnvironmentVariable("TwilioAccountSid")
            ?? throw new InvalidOperationException("TwilioAccountSid is not configured.");
        string authToken = Environment.GetEnvironmentVariable("TwilioAuthToken")
            ?? throw new InvalidOperationException("TwilioAuthToken is not configured.");
        string fromNumber = Environment.GetEnvironmentVariable("TwilioPhoneNumber")
            ?? throw new InvalidOperationException("TwilioPhoneNumber is not configured.");

        TwilioClient.Init(accountSid, authToken);
        await MessageResource.CreateAsync(
            to: new PhoneNumber(phoneNumber),
            from: new PhoneNumber(fromNumber),
            body: $"Your verification code is {challengeCode:0000}");

        return challengeCode;
    }
}

ملحوظة

لتشغيل عينة العامل المعزولة، قم بتثبيت Twilio حزمة NuGet. قم بضبط TwilioAccountSidإعدادات ، TwilioAuthToken، والتطبيق TwilioPhoneNumber .

النموذج أثناء العملية

[FunctionName("E4_SendSmsChallenge")]
public static int SendSmsChallenge(
    [ActivityTrigger] string phoneNumber,
    ILogger log,
    [TwilioSms(AccountSidSetting = "TwilioAccountSid", AuthTokenSetting = "TwilioAuthToken", From = "%TwilioPhoneNumber%")]
        out CreateMessageOptions message)
{
    // Get a random number generator with a random seed (not time-based)
    var rand = new Random(Guid.NewGuid().GetHashCode());
    int challengeCode = rand.Next(10000);

    log.LogInformation($"Sending verification code {challengeCode} to {phoneNumber}.");

    message = new CreateMessageOptions(new PhoneNumber(phoneNumber));
    message.Body = $"Your verification code is {challengeCode:0000}";

    return challengeCode;
}

ملحوظة

لتشغيل العينة، قم بتثبيت حزمة Microsoft.Azure.WebJobs.Extensions.Twilio NuGet. لا تثبت حزمة Twilio NuGet الرئيسية لأنها قد تسبب تعارضات في الإصدارات وأخطاء في البناء.

JavaScript

نموذج البرمجة V3

عرف ملف function.json كما يلي:

{
  "bindings": [
    {
      "name": "phoneNumber",
      "type": "activityTrigger",
      "direction": "in"
    },
    {
      "type": "twilioSms",
      "name": "message",
      "from": "%TwilioPhoneNumber%",
      "accountSidSetting": "TwilioAccountSid",
      "authTokenSetting": "TwilioAuthToken",
      "direction": "out"
    }
  ],
  "disabled": false
}

يقوم هذا الرمز بإنشاء رمز التحدي المكون من أربعة أرقام ويرسل رسالة SMS:

const seedrandom = require("seedrandom");
const uuidv1 = require("uuid/v1");

module.exports = function (context, phoneNumber) {
    // Get a random number generator with a random seed (not time-based)
    const rand = seedrandom(uuidv1());
    const challengeCode = Math.floor(rand() * 10000);

    context.log(`Sending verification code ${challengeCode} to ${phoneNumber}.`);

    context.bindings.message = {
        body: `Your verification code is ${challengeCode.toPrecision(4)}`,
        to: phoneNumber,
    };

    context.done(null, challengeCode);
};

نموذج البرمجة V4

إليك الرمز الذي يولد رمز التحدي المكون من أربعة أرقام ويرسل رسالة SMS:

const { output } = require("@azure/functions");
const df = require("durable-functions");

const sendSmsChallengeActivityName = "sendSmsChallenge";

const twilioOutput = output.generic({
    type: "twilioSms",
    from: "%TwilioPhoneNumber%",
    accountSidSetting: "TwilioAccountSid",
    authTokenSetting: "TwilioAuthToken",
});

df.app.activity(sendSmsChallengeActivityName, {
    extraOutputs: [twilioOutput],
    handler: function (phoneNumber, context) {
        // Get a random challenge code
        const challengeCode = Math.floor(Math.random() * 10000);

        context.log(`Sending verification code ${challengeCode} to ${phoneNumber}.`);

        context.extraOutputs.set(twilioOutput, {
            body: `Your verification code is ${challengeCode.toPrecision(4)}`,
            to: phoneNumber,
        });

        return challengeCode;
    },
});

Python

عرف ملف function.json كما يلي:

{
  "bindings": [
    {
      "name": "phoneNumber",
      "type": "activityTrigger",
      "direction": "in"
    },
    {
      "type": "twilioSms",
      "name": "message",
      "from": "%TwilioPhoneNumber%",
      "accountSidSetting": "TwilioAccountSid",
      "authTokenSetting": "TwilioAuthToken",
      "direction": "out"
    }
  ]
}

يقوم هذا الرمز بإنشاء رمز التحدي المكون من أربعة أرقام ويرسل رسالة SMS:

import json
import random

random.seed(10)

def main(phoneNumber, message):
  code = random.randint(0, 10000)
  payload = {
    "body": f"Your verification code is {code}",
    "to": phoneNumber
  }

  message.set(json.dumps(payload))
  code_str = str(code)
  return code_str

بوويرشيل

ينتج النشاط رمز تحدي عشوائي مكون من أربعة أرقام. في التطبيق الحقيقي، يرسل هذا الرمز أيضا رسالة SMS إلى رقم الهاتف المحدد.

param($phoneNumber)

# Generate a random four-digit challenge code
$challengeCode = Get-Random -Minimum 1000 -Maximum 10000

Write-Host "Sending verification code $challengeCode to $phoneNumber."

# In a real app, send the SMS here using Twilio or another provider
$challengeCode

Java

@FunctionName("E4_SendSmsChallenge")
public int sendSmsChallenge(
        @DurableActivityTrigger(name = "phoneNumber") String phoneNumber) {

    // Generate a random four-digit challenge code
    int challengeCode = ThreadLocalRandom.current().nextInt(1000, 10000);

    // In a real app, send the SMS here using Twilio or another provider
    Logger logger = Logger.getLogger("E4_SendSmsChallenge");
    logger.info(String.format("Sending verification code %d to %s.", challengeCode, phoneNumber));

    return challengeCode;
}

تقوم الأنشطة بتقديم طلب الموافقة ومعالجة الرد.

نشاط طلب الموافقة على تقديم

C#‎

using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

[DurableTask(nameof(SubmitApprovalRequestActivity))]
public class SubmitApprovalRequestActivity : TaskActivity<ApprovalRequestData, SubmissionResult>
{
    private readonly ILogger<SubmitApprovalRequestActivity> _logger;

    public SubmitApprovalRequestActivity(ILogger<SubmitApprovalRequestActivity> logger)
    {
        _logger = logger;
    }

    public override Task<SubmissionResult> RunAsync(
        TaskActivityContext context, ApprovalRequestData input)
    {
        _logger.LogInformation(
            "Submitting approval request {RequestId} from {Requester} for {Item}",
            input.RequestId, input.Requester, input.Item);

        // In a real system, this would send an email, notification, or update a database
        var result = new SubmissionResult
        {
            RequestId = input.RequestId,
            Status = "Pending",
            SubmittedAt = DateTime.UtcNow.ToString("o"),
            ApprovalUrl = $"http://localhost:8000/api/approvals/{input.RequestId}"
        };

        return Task.FromResult(result);
    }
}

JavaScript

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

const submitRequest = async (
  _ctx: ActivityContext,
  request: { amount: number }
): Promise<string> => {
  console.log(
    `[submitRequest] Purchase request submitted: $${request.amount}`
  );
  return `REQ-${Date.now()}`;
};

Python

import datetime
from durabletask import task

def submit_approval_request(ctx: task.ActivityContext, request_data: dict) -> dict:
    """
    Activity that submits an approval request.
    In a real application, this would notify a human approver via email, message, etc.
    """
    request_id = request_data.get("request_id")
    requester = request_data.get("requester")
    item = request_data.get("item")

    # In a real system, this would send an email, notification, or update a database
    return {
        "request_id": request_id,
        "status": "Pending",
        "submitted_at": datetime.datetime.now().isoformat(),
        "approval_url": f"http://localhost:8000/api/approvals/{request_id}"
    }

بوويرشيل

تم عرض هذه العينة لأنظمة .NET وJavaScript وJava وPython.

Java

عينة Java تقدم طلب الموافقة بشكل متكامل. بالنسبة لتطبيق الإنتاج، أنشئ نشاطا منفصلا:

.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "SubmitApprovalRequest"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            ApprovalRequest request = ctx.getInput(ApprovalRequest.class);

            // In a real system, send email/notification
            logger.info("Submitting approval request for " + request.item);

            return new SubmissionResult(
                "Pending",
                Instant.now().toString(),
                "http://localhost:8000/api/approvals/" + request.requester);
        };
    }
})

نشاط الموافقة على العمليات

C#‎

using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

[DurableTask(nameof(ProcessApprovalActivity))]
public class ProcessApprovalActivity : TaskActivity<ProcessApprovalInput, ApprovalResult>
{
    private readonly ILogger<ProcessApprovalActivity> _logger;

    public ProcessApprovalActivity(ILogger<ProcessApprovalActivity> logger)
    {
        _logger = logger;
    }

    public override Task<ApprovalResult> RunAsync(
        TaskActivityContext context, ProcessApprovalInput input)
    {
        string status = input.IsApproved ? "Approved" : "Rejected";
        _logger.LogInformation(
            "Processing {Status} request {RequestId} by {Approver}",
            status, input.RequestId, input.Approver);

        // In a real system, this would update a database, trigger workflows, etc.
        var result = new ApprovalResult
        {
            RequestId = input.RequestId,
            Status = status,
            ProcessedAt = DateTime.UtcNow.ToString("o"),
            Approver = input.Approver
        };

        return Task.FromResult(result);
    }
}

// Data classes
public class ApprovalRequestData
{
    public string RequestId { get; set; } = string.Empty;
    public string Requester { get; set; } = string.Empty;
    public string Item { get; set; } = string.Empty;
    public double TimeoutHours { get; set; } = 24.0;
}

public class ApprovalResponseData
{
    public bool IsApproved { get; set; }
    public string Approver { get; set; } = string.Empty;
}

public class SubmissionResult
{
    public string RequestId { get; set; } = string.Empty;
    public string Status { get; set; } = string.Empty;
    public string SubmittedAt { get; set; } = string.Empty;
    public string ApprovalUrl { get; set; } = string.Empty;
}

public class ProcessApprovalInput
{
    public string RequestId { get; set; } = string.Empty;
    public bool IsApproved { get; set; }
    public string Approver { get; set; } = string.Empty;
}

public class ApprovalResult
{
    public string RequestId { get; set; } = string.Empty;
    public string Status { get; set; } = string.Empty;
    public string ProcessedAt { get; set; } = string.Empty;
    public string? Approver { get; set; }
}

JavaScript

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

const processApproval = async (
  _ctx: ActivityContext,
  data: { requestId: string; approved: boolean }
): Promise<string> => {
  console.log(
    `[processApproval] Request ${data.requestId}: ${
      data.approved ? "APPROVED" : "REJECTED"
    }`
  );
  return data.approved ? "Order placed" : "Order cancelled";
};

const notifyTimeout = async (
  _ctx: ActivityContext,
  requestId: string
): Promise<string> => {
  console.log(
    `[notifyTimeout] Request ${requestId} timed out — auto-rejected`
  );
  return "Timed out — auto-rejected";
};

Python

import datetime
from durabletask import task

def process_approval(ctx: task.ActivityContext, approval_data: dict) -> dict:
    """
    Activity that processes the approval once received.
    """
    request_id = approval_data.get("request_id")
    is_approved = approval_data.get("is_approved")
    approver = approval_data.get("approver")

    status = "Approved" if is_approved else "Rejected"

    # In a real system, this would update a database, trigger workflows, etc.
    return {
        "request_id": request_id,
        "status": status,
        "processed_at": datetime.datetime.now().isoformat(),
        "approver": approver
    }

بوويرشيل

تم عرض هذه العينة لأنظمة .NET وJavaScript وJava وPython.

Java

تعالج عينة Java الموافقات المدمجة في المنظم. بالنسبة لتطبيق الإنتاج، أنشئ نشاطا منفصلا.

تشغيل عينة التفاعل البشري

استخدم الوظائف التي يتم تفعيلها بواسطة HTTP في العينة لبدء التنسيق عن طريق إرسال طلب HTTP POST التالي:

POST http://{host}/orchestrators/E4_SmsPhoneVerification
Content-Length: 14
Content-Type: application/json

"+1425XXXXXXX"

HTTP/1.1 202 Accepted
Content-Type: application/json; charset=utf-8

{"id":"741c65651d4c40cea29acdd5bb47baf1",
 "sendEventPostUri":"http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1/raiseEvent/{eventName}?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}",
 "statusQueryGetUri":"http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1?taskHub=...&code={systemKey}",
 "terminatePostUri":"http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1/terminate?reason={text}&taskHub=...&code={systemKey}"}

تستقبل وظيفة المنسق رقم الهاتف وترسل فورا رسالة نصية إلى ذلك الرقم مع رمز تحقق عشوائي مكون من 4 أرقام—على سبيل المثال، 2168. ثم تنتظر الوظيفة 90 ثانية لاستجابة.

للرد بالكود، استخدم RaiseEventAsync (.NET) أو raiseEvent (JavaScript و TypeScript) في دالة أخرى، أو استدعي نقطة نهاية HTTP POST في الرد 202 sendEventPostUri HTTP POST. استبدل {eventName} ب SmsChallengeResponse:

POST http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1/raiseEvent/SmsChallengeResponse?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}
Content-Length: 4
Content-Type: application/json

2168

إذا أرسلت الحدث قبل انتهاء المؤقت، يكتمل التوزيع الموسيقي، ويتم تعيين output الحقل على true، مما يشير إلى نجاح التأكيد.

GET http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

HTTP/1.1 200 OK
Content-Length: 144
Content-Type: application/json; charset=utf-8

{"runtimeStatus":"Completed","input":"+1425XXXXXXX","output":true,"createdTime":"2026-04-23T19:10:49Z","lastUpdatedTime":"2026-04-23T19:12:23Z"}

إذا انتهى المؤقت أو أدخلت رمزا خاطئا أربع مرات، استعلام الحالة لرؤية output التعيين على false، مما يشير إلى فشل التحقق من الهاتف.

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 145

{"runtimeStatus":"Completed","input":"+1425XXXXXXX","output":false,"createdTime":"2026-04-23T19:20:49Z","lastUpdatedTime":"2026-04-23T19:22:23Z"}

لتشغيل العينة:

1. ابدأ محاكي جدولة المهام الدائمة للتطوير المحلي. يجب تثبيت Docker.

   docker run -d -p 8080:8080 -p 8082:8082 --name dts-emulator mcr.microsoft.com/dts/dts-emulator:latest
   

2. ابدأ العامل بتسجيل المنظم والأنشطة.

3. شغل العميل لجدولة سير عمل الموافقة وإرسال الأحداث.

C#‎

using System;
using System.Threading.Tasks;

var client = DurableTaskClientBuilder.UseDurableTaskScheduler(connectionString).Build();

// Schedule the approval workflow
var input = new ApprovalRequestData
{
    RequestId = "request-" + Guid.NewGuid().ToString(),
    Requester = "john.doe@example.com",
    Item = "Vacation Request - 5 days",
    TimeoutHours = 24
};

string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
    nameof(ApprovalOrchestration), input);

Console.WriteLine($"Started approval workflow: {instanceId}");

// Simulate human approving the request
Console.WriteLine("Simulating approval...");
await Task.Delay(2000);

// Raise the approval event
var approvalResponse = new ApprovalResponseData
{
    IsApproved = true,
    Approver = "manager@example.com"
};

await client.RaiseEventAsync(instanceId, "approval_response", approvalResponse);

// Wait for completion
var result = await client.WaitForInstanceCompletionAsync(instanceId, getInputsAndOutputs: true);
Console.WriteLine($"Result: {result.ReadOutputAs<ApprovalResult>().Status}");

JavaScript

import {
  DurableTaskAzureManagedClientBuilder,
  DurableTaskAzureManagedWorkerBuilder,
} from "@microsoft/durabletask-js-azuremanaged";

const client = new DurableTaskAzureManagedClientBuilder()
  .connectionString(connectionString)
  .build();

const worker = new DurableTaskAzureManagedWorkerBuilder()
  .connectionString(connectionString)
  .addOrchestrator(approvalOrchestrator)
  .addActivity(submitRequest)
  .addActivity(processApproval)
  .addActivity(notifyTimeout)
  .build();

await worker.start();

// Schedule the approval workflow
const approvalId = await client.scheduleNewOrchestration(
  approvalOrchestrator,
  500 // amount
);

console.log(`Orchestration started: ${approvalId}`);

// Wait for it to reach "Awaiting approval", then send approval
await new Promise((r) => setTimeout(r, 3000));

await client.raiseOrchestrationEvent(approvalId, "approval", {
  approved: true,
});
console.log("Sent approval event");

const result = await client.waitForOrchestrationCompletion(
  approvalId,
  true,
  60
);
console.log(`Result: ${result?.serializedOutput}`);

await worker.stop();
await client.stop();

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient
import time
import uuid

client = DurableTaskSchedulerClient(
    host_address=endpoint,
    secure_channel=endpoint != "http://localhost:8080",
    taskhub=taskhub,
    token_credential=credential
)

# Schedule the approval workflow
input_data = {
    "request_id": f"request-{uuid.uuid4()}",
    "requester": "john.doe@example.com",
    "item": "Vacation Request - 5 days",
    "timeout_hours": 24
}

instance_id = client.schedule_new_orchestration(
    human_interaction_orchestrator,
    input=input_data
)

print(f"Started approval workflow: {instance_id}")

# Simulate human approving the request
print("Simulating approval...")
time.sleep(2)

# Raise the approval event
approval_response = {
    "is_approved": True,
    "approver": "manager@example.com"
}

client.raise_orchestration_event(instance_id, "approval_response", data=approval_response)

# Wait for completion
result = client.wait_for_orchestration_completion(instance_id, timeout=60)
print(f"Result: {result.serialized_output}")

بوويرشيل

تم عرض هذه العينة لأنظمة .NET وJavaScript وJava وPython.

Java

import java.time.Duration;
import java.time.Instant;
import java.util.UUID;

DurableTaskClient client = DurableTaskSchedulerClientExtensions
    .createClientBuilder(connectionString).build();

// Schedule the approval workflow
ApprovalRequest request = new ApprovalRequest(
    "john.doe@example.com",
    "Vacation Request - 5 days",
    24  // timeout hours
);

String instanceId = client.scheduleNewOrchestrationInstance(
    "ApprovalWorkflow",
    new NewOrchestrationInstanceOptions()
        .setInput(request)
        .setInstanceId("request-" + UUID.randomUUID().toString()));

System.out.println("Started approval workflow: " + instanceId);

// Simulate human approving the request
System.out.println("Simulating approval...");
Thread.sleep(2000);

// Raise the approval event
ApprovalResponse response = new ApprovalResponse(
    true,  // isApproved
    "manager@example.com",
    "Approved",
    Instant.now().toString()
);

client.raiseEvent(instanceId, "approval_response", response);

// Wait for completion
OrchestrationMetadata result = client.waitForInstanceCompletion(
    instanceId, Duration.ofSeconds(60), true);

System.out.println("Result: " + result.readOutputAs(WorkflowResult.class).status);

الخطوات التالية

تظهر هذه العينة قدرات Durable Functions متقدمة، بما في ذلك واجهات برمجة التطبيقات WaitForExternalEvent و CreateTimer. يوضح كيفية دمج Task.WhenAny (C#)، context.df.Task.any (جافا سكريبت وTypeScript)، أو context.task_any (Python) لتنفيذ نمط مهلة موثوقة لسير العمل الذي ينتظر استجابة الناس.

تعرف على Durable Functions القيود

• المؤقتات المتانة
• الأحداث الخارجية وإدارة العينات
• التوزيع الأبدي

توضح هذه العينة كيفية استخدام مجموعات تطوير المهام المتطورة لتنفيذ سير عمل تنتظر استجابة الناس، مع مهلات زمنية قابلة للتكوين. المفاهيم الأساسية:

• الأحداث الخارجية: استخدام WaitForExternalEvent انتظار المدخلات
• مؤقتات متينة: استخدامها CreateTimer لتنفيذ المهمات المفتوحة
• مهام السباق: استخدام WhenAny، when_any، أو anyOf للتعامل مع المهمة التي تكتمل أولا

ابدأ مع مجموعات تطوير المهام الدائمة

• المؤقتات المتانة
• التوزيع الأبدي
• Durable Task JavaScript SDK على GitHub