Externe gebeurtenissen in Durable Functions verwerken (Azure Functions)Handling external events in Durable Functions (Azure Functions)

Orchestrator-functies hebben de mogelijkheid om te wachten op externe gebeurtenissen en te Luis teren.Orchestrator functions have the ability to wait and listen for external events. Deze functie van Durable functions is vaak handig voor het afhandelen van menselijke interactie of andere externe triggers.This feature of Durable Functions is often useful for handling human interaction or other external triggers.

Notitie

Externe gebeurtenissen zijn asynchrone bewerkingen in één richting.External events are one-way asynchronous operations. Deze zijn niet geschikt voor situaties waarin de client die de gebeurtenis verzendt, een synchrone reactie van de Orchestrator-functie nodig heeft.They are not suitable for situations where the client sending the event needs a synchronous response from the orchestrator function.

Wachten op gebeurtenissenWait for events

Met de methode WaitForExternalEvent kan een Orchestrator-functie asynchroon worden gewacht en geluisterd op een externe gebeurtenis.The WaitForExternalEvent method allows an orchestrator function to asynchronously wait and listen for an external event. De functie voor het Luis teren van Orchestrator declareert de naam van de gebeurtenis en de vorm van de gegevens die ze verwacht te ontvangen.The listening orchestrator function declares the name of the event and the shape of the data it expects to receive.

C#C#

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

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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

In het voor gaande voor beeld wordt geluisterd naar een specifieke gebeurtenis en wordt er actie ondernomen wanneer het wordt ontvangen.The preceding example listens for a specific single event and takes action when it's received.

U kunt gelijktijdig naar meerdere gebeurtenissen Luis teren, zoals in het volgende voor beeld, waarin wordt gewacht op een van de drie mogelijke gebeurtenis meldingen.You can listen for multiple events concurrently, like in the following example, which waits for one of three possible event notifications.

C#C#

[FunctionName("Select")]
public static async Task Run(
    [OrchestrationTrigger] DurableOrchestrationContext 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)
    {
        // ...
    }
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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) {
        // ...
    }
});

In het vorige voor beeld wordt geluisterd naar een of meer gebeurtenissen.The previous example listens for any of multiple events. Het is ook mogelijk te wachten op alle gebeurtenissen.It's also possible to wait for all events.

C#C#

[FunctionName("NewBuildingPermit")]
public static async Task Run(
    [OrchestrationTrigger] DurableOrchestrationContext 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);
}

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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

WaitForExternalEvent wacht oneindig voor sommige invoer.WaitForExternalEvent waits indefinitely for some input. De functie-app kan tijdens het wachten veilig worden verwijderd.The function app can be safely unloaded while waiting. Als en wanneer een gebeurtenis arriveert voor dit Orchestrator-exemplaar, wordt deze automatisch geactiveerd en wordt de gebeurtenis onmiddellijk verwerkt.If and when an event arrives for this orchestration instance, it is awakened automatically and immediately processes the event.

Notitie

Als uw functie-app gebruikmaakt van het verbruiks abonnement, worden er geen facturerings kosten in rekening gebracht terwijl een Orchestrator-functie wacht WaitForExternalEvent op een taak van waitForExternalEvent (.net) of (Java script), ongeacht hoe lang het wacht.If your function app uses the Consumption Plan, no billing charges are incurred while an orchestrator function is awaiting a task from WaitForExternalEvent (.NET) or waitForExternalEvent (JavaScript), no matter how long it waits.

Als de nettolading van de gebeurtenis in .net niet kan worden geconverteerd naar het Tverwachte type, wordt er een uitzonde ring gegenereerd.In .NET, if the event payload cannot be converted into the expected type T, an exception is thrown.

Gebeurtenissen verzendenSend events

De methode RaiseEventAsync van de klasse DurableOrchestrationClient verzendt de gebeurtenissen die WaitForExternalEvent (.net) of waitForExternalEvent (Java script) wachten op.The RaiseEventAsync method of the DurableOrchestrationClient class sends the events that WaitForExternalEvent (.NET) or waitForExternalEvent (JavaScript) waits for. Voor RaiseEventAsync de-methode worden eventname en Event Data als para meters gebruikt.The RaiseEventAsync method takes eventName and eventData as parameters. De gebeurtenis gegevens moeten JSON-serialiseerbaar zijn.The event data must be JSON-serializable.

Hieronder ziet u een voor beeld van een door de wachtrij geactiveerde functie die een ' goed keuring ' gebeurtenis naar een Orchestrator-functie exemplaar verzendt.Below is an example queue-triggered function that sends an "Approval" event to an orchestrator function instance. De indelings exemplaar-ID is afkomstig van de hoofd tekst van het wachtrij bericht.The orchestration instance ID comes from the body of the queue message.

C#C#

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

Java script (alleen functies 2. x)JavaScript (Functions 2.x only)

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

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

Intern, RaiseEventAsync (.net) of raiseEvent (Java script) in een bericht dat wordt opgehaald door de functie voor wachtende functies.Internally, RaiseEventAsync (.NET) or raiseEvent (JavaScript) enqueues a message that gets picked up by the waiting orchestrator function. Als het exemplaar niet op de opgegeven gebeurtenis naam wacht, wordt het gebeurtenis bericht toegevoegd aan een in-Memory wachtrij.If the instance is not waiting on the specified event name, the event message is added to an in-memory queue. Als het Orchestrator-exemplaar later begint met Luis teren naar die gebeurtenis naam, wordt de wachtrij gecontroleerd op gebeurtenis berichten.If the orchestration instance later begins listening for that event name, it will check the queue for event messages.

Notitie

Als er geen Orchestrator-exemplaar is met de opgegeven exemplaar-id, wordt het gebeurtenis bericht verwijderd.If there is no orchestration instance with the specified instance ID, the event message is discarded. Zie het github-probleemvoor meer informatie over dit gedrag.For more information about this behavior, see the GitHub issue.

Waarschuwing

Bij het lokaal ontwikkelen in Java script moet u de omgevings variabele WEBSITE_HOSTNAME instellen op localhost:<port>, bijvoorbeeld.When developing locally in JavaScript, you will need to set the environment variable WEBSITE_HOSTNAME to localhost:<port>, ex. localhost:7071om methoden te gebruiken DurableOrchestrationClientin.localhost:7071 to use methods on DurableOrchestrationClient. Zie het github-probleemvoor meer informatie over deze vereiste.For more information about this requirement, see the GitHub issue.

Volgende stappenNext steps