Обработка внешних событий

Функции Оркестратора могут ожидать и прослушивать внешние события. Эта функция Durable Functions часто полезна для обработки взаимодействия с человеком или других внешних триггеров.

Замечание

Внешние события — это односторонняя асинхронная операция. Они не подходят для ситуаций, когда клиент, отправляющий событие, нуждается в синхронном ответе от функции оркестратора.

Оркестрации могут ждать и прослушивать внешние события. Эта функция часто полезна для обработки взаимодействия с человеком или других внешних триггеров.

Замечание

Внешние события — это односторонняя асинхронная операция. Они не подходят для случаев, когда клиент, отправляющий событие, нуждается в синхронном отклике от оркестрации.

Это важно

В настоящее время пакет SDK для устойчивых задач PowerShell недоступен.

Ожидание событий

API "wait-for-external-event" для привязки триггера оркестрации позволяет функции оркестратора асинхронно ожидать и отслеживать событие, доставленное внешним клиентом. Функция оркестратора прослушивания объявляет имя события и форму получаемых данных .

API wait-for-external-event позволяет оркестрации асинхронно ожидать и прослушивать событие, доставленное внешним клиентом. Прослушивающая оркестрация объявляет имя события и структуру данных, которые она ожидает получить.

C#

Изолированная рабочая модель

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

public class BudgetApproval
{
    private readonly ILogger _logger;

    public BudgetApproval(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<BudgetApproval>();
    }

    [Function("BudgetApproval")]
    public async Task Run(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        bool approved = await context.WaitForExternalEventAsync<bool>("Approval");
        if (approved)
        {
            // approval granted - do the approved action
        }
        else
        {
            // approval denied - send a notification
        }
    }
}

Модель внутрипроцессного процесса

[FunctionName("BudgetApproval")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    bool approved = await context.WaitForExternalEvent<bool>("Approval");
    if (approved)
    {
        // approval granted - do the approved action
    }
    else
    {
        // approval denied - send a notification
    }
}

Замечание

Если вы используете Durable Functions 1.x, используйте DurableOrchestrationContext вместо IDurableOrchestrationContext. Дополнительные сведения см. в статье о версиях Durable Functions.

JavaScript

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

module.exports = df.orchestrator(function*(context) {
    const approved = yield context.df.waitForExternalEvent("Approval");
    if (approved) {
        // approval granted - do the approved action
    } else {
        // approval denied - send a notification
    }
});

Python

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    approved = yield context.wait_for_external_event('Approval')
    if approved:
        # approval granted - do the approved action
    else:
        # approval denied - send a notification

main = df.Orchestrator.create(orchestrator_function)

Java

@FunctionName("WaitForExternalEvent")
public void waitForExternalEvent(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    boolean approved = ctx.waitForExternalEvent("Approval", boolean.class).await();
    if (approved) {
        // approval granted - do the approved action
    } else {
        // approval denied - send a notification
    }
}

PowerShell

param($Context)

$approved = Start-DurableExternalEventListener -EventName "Approval"

if ($approved) {
    # approval granted - do the approved action
} else {
    # approval denied - send a notification
}

C#

public class BudgetApproval : TaskOrchestrator<object?, bool>
{
    public override async Task<bool> RunAsync(TaskOrchestrationContext context, object? input)
    {
        bool approved = await context.WaitForExternalEvent<bool>("Approval");
        if (approved)
        {
            // approval granted - do the approved action
        }
        else
        {
            // approval denied - send a notification
        }
        return approved;
    }
}

Python

from durabletask import task

def budget_approval(ctx: task.OrchestrationContext, _):
    approved = yield ctx.wait_for_external_event("Approval")
    if approved:
        # approval granted - do the approved action
        pass
    else:
        # approval denied - send a notification
        pass
    return approved

Java

public class BudgetApproval implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        boolean approved = ctx.waitForExternalEvent("Approval", boolean.class).await();
        if (approved) {
            // approval granted - do the approved action
        } else {
            // approval denied - send a notification
        }
    }
}

JavaScript

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

const budgetApproval: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const approved = yield ctx.waitForExternalEvent("Approval");
    if (approved) {
        // approval granted - do the approved action
    } else {
        // approval denied - send a notification
    }
    return approved;
};

PowerShell

Пакет SDK для устойчивых задач недоступен для PowerShell. Вместо этого используйте Durable Functions.

Предыдущий пример прослушивает одно конкретное событие и выполняет действия при его получении.

Вы можете прослушивать несколько событий одновременно, например в следующем примере, которое ожидает одного из трех возможных уведомлений о событиях.

C#

Изолированная рабочая модель

[Function("Select")]
public async Task Run(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    Task<float> event1 = context.WaitForExternalEventAsync<float>("Event1");
    Task<bool> event2 = context.WaitForExternalEventAsync<bool>("Event2");
    Task<int> event3 = context.WaitForExternalEventAsync<int>("Event3");

    Task winner = await Task.WhenAny(event1, event2, event3);
    if (winner == event1)
    {
        // ...
    }
    else if (winner == event2)
    {
        // ...
    }
    else if (winner == event3)
    {
        // ...
    }
}

Модель внутрипроцессного процесса

[FunctionName("Select")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var event1 = context.WaitForExternalEvent<float>("Event1");
    var event2 = context.WaitForExternalEvent<bool>("Event2");
    var event3 = context.WaitForExternalEvent<int>("Event3");

    var winner = await Task.WhenAny(event1, event2, event3);
    if (winner == event1)
    {
        // ...
    }
    else if (winner == event2)
    {
        // ...
    }
    else if (winner == event3)
    {
        // ...
    }
}

Замечание

Использование Durable Functions 1.x? Замените DurableOrchestrationContext на IDurableOrchestrationContext. Дополнительные сведения о других различиях версий см. в статье Durable Functions.

JavaScript

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

module.exports = df.orchestrator(function*(context) {
    const event1 = context.df.waitForExternalEvent("Event1");
    const event2 = context.df.waitForExternalEvent("Event2");
    const event3 = context.df.waitForExternalEvent("Event3");

    const winner = yield context.df.Task.any([event1, event2, event3]);
    if (winner === event1) {
        // ...
    } else if (winner === event2) {
        // ...
    } else if (winner === event3) {
        // ...
    }
});

Python

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    event1 = context.wait_for_external_event('Event1')
    event2 = context.wait_for_external_event('Event2')
    event3 = context.wait_for_external_event('Event3')

    winner = yield context.task_any([event1, event2, event3])
    if winner == event1:
        # ...
    elif winner == event2:
        # ...
    elif winner == event3:
        # ...

main = df.Orchestrator.create(orchestrator_function)

Java

@FunctionName("Select")
public void selectOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    Task<Void> event1 = ctx.waitForExternalEvent("Event1");
    Task<Void> event2 = ctx.waitForExternalEvent("Event2");
    Task<Void> event3 = ctx.waitForExternalEvent("Event3");

    Task<?> winner = ctx.anyOf(event1, event2, event3).await();
    if (winner == event1) {
        // ...
    } else if (winner == event2) {
        // ...
    } else if (winner == event3) {
        // ...
    }
}

PowerShell

param($Context)

$event1 = Start-DurableExternalEventListener -EventName "Event1" -NoWait
$event2 = Start-DurableExternalEventListener -EventName "Event2" -NoWait
$event3 = Start-DurableExternalEventListener -EventName "Event3" -NoWait

$winner = Wait-DurableTask -Task @($event1, $event2, $event3) -Any

if ($winner -eq $event1) {
    # ...
} else if ($winner -eq $event2) {
    # ...
} else if ($winner -eq $event3) {
    # ...
}

C#

public class SelectOrchestrator : TaskOrchestrator<object?, object?>
{
    public override async Task<object?> RunAsync(TaskOrchestrationContext context, object? input)
    {
        Task<float> event1 = context.WaitForExternalEvent<float>("Event1");
        Task<bool> event2 = context.WaitForExternalEvent<bool>("Event2");
        Task<int> event3 = context.WaitForExternalEvent<int>("Event3");

        Task winner = await Task.WhenAny(event1, event2, event3);
        if (winner == event1)
        {
            // ...
        }
        else if (winner == event2)
        {
            // ...
        }
        else if (winner == event3)
        {
            // ...
        }
        return null;
    }
}

Python

from durabletask import task

def select_orchestrator(ctx: task.OrchestrationContext, _):
    event1 = ctx.wait_for_external_event("Event1")
    event2 = ctx.wait_for_external_event("Event2")
    event3 = ctx.wait_for_external_event("Event3")

    winner = yield task.when_any([event1, event2, event3])
    if winner == event1:
        # ...
        pass
    elif winner == event2:
        # ...
        pass
    elif winner == event3:
        # ...
        pass

Java

public class SelectOrchestrator implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        Task<Void> event1 = ctx.waitForExternalEvent("Event1");
        Task<Void> event2 = ctx.waitForExternalEvent("Event2");
        Task<Void> event3 = ctx.waitForExternalEvent("Event3");

        Task<?> winner = ctx.anyOf(event1, event2, event3).await();
        if (winner == event1) {
            // ...
        } else if (winner == event2) {
            // ...
        } else if (winner == event3) {
            // ...
        }
    }
}

JavaScript

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

const selectOrchestrator: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const event1 = ctx.waitForExternalEvent("Event1");
    const event2 = ctx.waitForExternalEvent("Event2");
    const event3 = ctx.waitForExternalEvent("Event3");

    const winner = yield whenAny([event1, event2, event3]);
    if (winner === event1) {
        // ...
    } else if (winner === event2) {
        // ...
    } else if (winner === event3) {
        // ...
    }
};

PowerShell

Пакет SDK для устойчивых задач недоступен для PowerShell. Вместо этого используйте Durable Functions.

В предыдущем примере прослушивается любое из нескольких событий. Вы также можете ждать всех событий.

C#

Изолированная рабочая модель

[Function("NewBuildingPermit")]
public async Task Run(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string applicationId = context.GetInput<string>();

    Task gate1 = context.WaitForExternalEventAsync<object>("CityPlanningApproval");
    Task gate2 = context.WaitForExternalEventAsync<object>("FireDeptApproval");
    Task gate3 = context.WaitForExternalEventAsync<object>("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    await Task.WhenAll(gate1, gate2, gate3);

    await context.CallActivityAsync("IssueBuildingPermit", applicationId);
}

Модель внутрипроцессного процесса

[FunctionName("NewBuildingPermit")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string applicationId = context.GetInput<string>();

    var gate1 = context.WaitForExternalEvent("CityPlanningApproval");
    var gate2 = context.WaitForExternalEvent("FireDeptApproval");
    var gate3 = context.WaitForExternalEvent("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    await Task.WhenAll(gate1, gate2, gate3);

    await context.CallActivityAsync("IssueBuildingPermit", applicationId);
}

Замечание

Если вы используете Durable Functions 1.x, используйте DurableOrchestrationContext вместо IDurableOrchestrationContext. Перейдите к Durable Functions версии для полного описания различий версий.

В .NET, если полезные данные события не могут быть преобразованы в ожидаемый тип T, выбрасывается исключение.

JavaScript

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

module.exports = df.orchestrator(function*(context) {
    const applicationId = context.df.getInput();

    const gate1 = context.df.waitForExternalEvent("CityPlanningApproval");
    const gate2 = context.df.waitForExternalEvent("FireDeptApproval");
    const gate3 = context.df.waitForExternalEvent("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    yield context.df.Task.all([gate1, gate2, gate3]);

    yield context.df.callActivity("IssueBuildingPermit", applicationId);
});

Python

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    application_id = context.get_input()

    gate1 = context.wait_for_external_event('CityPlanningApproval')
    gate2 = context.wait_for_external_event('FireDeptApproval')
    gate3 = context.wait_for_external_event('BuildingDeptApproval')

    yield context.task_all([gate1, gate2, gate3])
    yield context.call_activity('IssueBuildingPermit', application_id)

main = df.Orchestrator.create(orchestrator_function)

Java

@FunctionName("NewBuildingPermit")
public void newBuildingPermit(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    String applicationId = ctx.getInput(String.class);

    Task<Void> gate1 = ctx.waitForExternalEvent("CityPlanningApproval");
    Task<Void> gate2 = ctx.waitForExternalEvent("FireDeptApproval");
    Task<Void> gate3 = ctx.waitForExternalEvent("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    ctx.allOf(List.of(gate1, gate2, gate3)).await();

    ctx.callActivity("IssueBuildingPermit", applicationId).await();
}

PowerShell

param($Context)

$applicationId = $Context.Input
$gate1 = Start-DurableExternalEventListener -EventName "CityPlanningApproval" -NoWait
$gate2 = Start-DurableExternalEventListener -EventName "FireDeptApproval" -NoWait
$gate3 = Start-DurableExternalEventListener -EventName "BuildingDeptApproval" -NoWait

Wait-DurableTask -Task @($gate1, $gate2, $gate3)

Invoke-ActivityFunction -FunctionName 'IssueBuildingPermit' -Input $applicationId

C#

public class NewBuildingPermit : TaskOrchestrator<string, object?>
{
    public override async Task<object?> RunAsync(TaskOrchestrationContext context, string applicationId)
    {
        Task<object?> gate1 = context.WaitForExternalEvent<object?>("CityPlanningApproval");
        Task<object?> gate2 = context.WaitForExternalEvent<object?>("FireDeptApproval");
        Task<object?> gate3 = context.WaitForExternalEvent<object?>("BuildingDeptApproval");

        // all three departments must grant approval before a permit can be issued
        await Task.WhenAll(gate1, gate2, gate3);

        await context.CallActivityAsync("IssueBuildingPermit", applicationId);
        return null;
    }
}

В .NET, если полезные данные события не могут быть преобразованы в ожидаемый тип T, выбрасывается исключение.

Python

from durabletask import task

def issue_building_permit(ctx: task.ActivityContext, application_id: str) -> None:
    # Issue the permit
    pass

def new_building_permit(ctx: task.OrchestrationContext, application_id: str):
    gate1 = ctx.wait_for_external_event("CityPlanningApproval")
    gate2 = ctx.wait_for_external_event("FireDeptApproval")
    gate3 = ctx.wait_for_external_event("BuildingDeptApproval")

    # all three departments must grant approval before a permit can be issued
    yield task.when_all([gate1, gate2, gate3])
    yield ctx.call_activity(issue_building_permit, input=application_id)

Java

public class NewBuildingPermit implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        String applicationId = ctx.getInput(String.class);

        Task<Void> gate1 = ctx.waitForExternalEvent("CityPlanningApproval");
        Task<Void> gate2 = ctx.waitForExternalEvent("FireDeptApproval");
        Task<Void> gate3 = ctx.waitForExternalEvent("BuildingDeptApproval");

        // all three departments must grant approval before a permit can be issued
        ctx.allOf(List.of(gate1, gate2, gate3)).await();

        ctx.callActivity("IssueBuildingPermit", applicationId).await();
    }
}

JavaScript

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

const issueBuildingPermit = async (_: ActivityContext, applicationId: string): Promise<void> => {
    // Issue the permit
};

const newBuildingPermit: TOrchestrator = async function* (
    ctx: OrchestrationContext,
    applicationId: string,
): any {
    const gate1 = ctx.waitForExternalEvent("CityPlanningApproval");
    const gate2 = ctx.waitForExternalEvent("FireDeptApproval");
    const gate3 = ctx.waitForExternalEvent("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    yield whenAll([gate1, gate2, gate3]);
    yield ctx.callActivity(issueBuildingPermit, applicationId);
};

PowerShell

Пакет SDK для устойчивых задач недоступен для PowerShell. Вместо этого используйте Durable Functions.

API "wait-for-external-event" ожидает неограниченное время для некоторых входных данных. Вы можете безопасно выгрузить функциональное приложение во время ожидания. Если и когда событие поступает для этого экземпляра оркестрации, экземпляр просыпается автоматически и немедленно обрабатывает событие.

Замечание

Если приложение-функция использует тарифный план 'По потреблению', плата не взимается, пока функция оркестратора ожидает внешнего события, независимо от времени ожидания.

Как и в случае с функциями действий, внешние события имеют по крайней мере однократную гарантию доставки. Это означает, что при определенных условиях (например, перезапуски, масштабирование, сбои и т. д.) приложение может получать дубликаты одного и того же внешнего события. Поэтому мы рекомендуем, чтобы внешние события содержали идентификатор, который позволяет вручную устранять дубликаты в системах оркестрации.

API "wait-for-external-event" ожидает неограниченное время для некоторых входных данных. Вы можете безопасно остановить процесс во время ожидания. Если и когда событие поступает для этого экземпляра оркестрации, оно просыпается автоматически и немедленно обрабатывает событие.

Внешние события имеют гарантию доставки хотя бы один раз. Это означает, что при определенных условиях (например, перезапуски, масштабирование, сбои и т. д.) приложение может получать дубликаты одного и того же внешнего события. Поэтому мы рекомендуем, чтобы внешние события содержали какой-то идентификатор, который позволяет вручную удалять дубликаты в оркестрациях.

Отправка событий

API raise-event, определенный привязкой клиента оркестровки, можно использовать для отправки внешнего события в оркестровку. Для отправки внешнего события в оркестрацию можно также использовать встроенный HTTP API для генерации события.

Инициированное событие включает instanceID, eventName, и eventData в качестве параметров. Функции оркестратора обрабатывают эти события с помощью wait-for-external-event API. Для того чтобы событие было обработано, eventName должен совпадать как на отправляющей, так и на принимающей стороне. Данные события также должны быть сериализуемыми в формате JSON.

Внутри системы механизмы "raise-event" поставляют в очередь сообщение, которое извлекается ожидающей функцией оркестратора. Если экземпляр не ожидает указанного имени события, сообщение о событии добавляется в очередь в памяти. Если экземпляр оркестрации позже начинает прослушивать это имя события, он проверяет очередь сообщений о событиях.

Замечание

Если экземпляр оркестрации с указанным идентификатором экземпляра отсутствует, сообщение о событии удаляется.

Ниже приведен пример функции с активацией очереди, которая отправляет событие "Утверждение" в экземпляр функции оркестратора. Идентификатор экземпляра оркестрации поступает из текста сообщения очереди.

API "raise-event" можно использовать в клиенте Durable Task для отправки внешнего события в оркестрацию.

Вызванное событие включает идентификатор экземпляра, имя события и данные события в качестве параметров. Оркестрации обрабатывают эти события с помощью API wait-for-external-event . Имя события должно совпадать как с отправкой, так и с получением, чтобы событие было обработано. Данные события также должны быть сериализуемыми в формате JSON.

Внутри системы механизмы "raise-event" помещают сообщение в очередь, которое затем обрабатывается ожидающей оркестрацией. Если экземпляр не ожидает указанного названия события, сообщение о событии добавляется в очередь в памяти. Если экземпляр оркестрации позже начинает прослушивать это имя события, он проверит очередь сообщений о событиях.

Замечание

Если в указанном instanceIDэкземпляре оркестрации нет, сообщение о событии удаляется.

Ниже приведен пример, который отправляет событие "Утверждение" в экземпляр оркестрации.

C#

Изолированная рабочая модель

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

public class ApprovalQueueProcessor
{
    [Function("ApprovalQueueProcessor")]
    public async Task Run(
        [QueueTrigger("approval-queue")] string instanceId,
        [DurableClient] DurableTaskClient client)
    {
        await client.RaiseEventAsync(instanceId, "Approval", true);
    }
}

Модель внутрипроцессного процесса

[FunctionName("ApprovalQueueProcessor")]
public static async Task Run(
    [QueueTrigger("approval-queue")] string instanceId,
    [DurableClient] IDurableOrchestrationClient client)
{
    await client.RaiseEventAsync(instanceId, "Approval", true);
}

Замечание

Для Durable Functions 1.x используйте вместо него атрибут OrchestrationClient и тип параметра DurableOrchestrationClient. Ознакомьтесь со статьёй о версиях Durable Functions для всех изменений, специфичных для каждой версии.

JavaScript

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);
    await client.raiseEvent(instanceId, "Approval", true);
};

Python

import azure.functions as func
import azure.durable_functions as df

async def main(instance_id:str, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)
    await client.raise_event(instance_id, 'Approval', True)

Java

@FunctionName("ApprovalQueueProcessor")
public void approvalQueueProcessor(
        @QueueTrigger(name = "instanceID", queueName = "approval-queue") String instanceID,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    durableContext.getClient().raiseEvent(instanceID, "Approval", true);
}

PowerShell

param($instanceId)

Send-DurableExternalEvent -InstanceId $InstanceId -EventName "Approval"

Во внутреннем интерфейсе API "raise-event" вложено сообщение, которое извлекается функцией оркестратора ожидания. Если экземпляр не ожидает указанного имени события, сообщение о событии добавляется в буфер в памяти. Если экземпляр оркестрации позже начинает прослушивать это имя события, он проверяет буфер на наличие сообщений о событиях и активирует задачу, ожидающую его.

Замечание

Если экземпляр оркестрации с указанным идентификатором экземпляра отсутствует, сообщение о событии удаляется.

C#

await client.RaiseEventAsync(instanceId, "Approval", true);

Python

client.raise_orchestration_event(instance_id, "Approval", data=True)

Java

client.raiseEvent(instanceId, "Approval", true);

JavaScript

await client.raiseOrchestrationEvent(instanceId, "Approval", true);

PowerShell

Пакет SDK для устойчивых задач недоступен для PowerShell. Вместо этого используйте Durable Functions.

Во внутреннем режиме API "raise-event" помещает в очередь сообщение, которое извлекается ожидающей оркестрацией. Если экземпляр не ожидает указанного имени события, сообщение события добавляется в буфер в памяти. Если экземпляр оркестрации позже начинает прослушивать данное имя события, он проверит буфер на сообщения о событиях и активирует задачу, ожидающую его.

Замечание

Если экземпляр оркестрации с указанным идентификатором экземпляра отсутствует, сообщение о событии удаляется.

HTTP

Ниже приведен пример HTTP-запроса, который вызывает Approval событие для экземпляра оркестрации.

POST /runtime/webhooks/durabletask/instances/MyInstanceId/raiseEvent/Approval&code=XXX
Content-Type: application/json

"true"

В этом случае идентификатор экземпляра жестко закодирован как MyInstanceId.

Рекомендации по внешним событиям

При работе с внешними событиями следует учитывать следующие рекомендации.

Использование уникальных имен событий для дедупликации

Внешние события имеют гарантию доставки хотя бы один раз. В некоторых редких условиях (которые могут возникать во время перезапуска, масштабирования или сбоя), приложение может получать дубликаты одного и того же внешнего события. Рекомендуется, чтобы внешние события содержали уникальный идентификатор, который позволяет выполнять дедупликацию вручную в оркестраторах.

Замечание

Поставщик хранилища MSSQL использует внешние события и транзакционно обновляет состояние оркестратора, поэтому, в отличие от поставщика Azure Storage, отсутствует риск дублированных событий. Однако по-прежнему рекомендуется, чтобы внешние события имели уникальные имена, чтобы код был переносимым между бэкендами.

Дальнейшие действия

Узнайте, как реализовать обработку ошибок

Запустите пример, который ожидает взаимодействия с человеком

Начало работы с Durable Task SDK