Duurzame integratiesDurable Orchestrations

Durable Functions is een uitbrei ding van Azure functions.Durable Functions is an extension of Azure Functions. U kunt een Orchestrator-functie gebruiken om de uitvoering van andere duurzame functies in een functie-app te organiseren.You can use an orchestrator function to orchestrate the execution of other Durable functions within a function app. Orchestrator-functies hebben de volgende kenmerken:Orchestrator functions have the following characteristics:

  • Met Orchestrator-functies worden functie werk stromen gedefinieerd met behulp van procedurele code.Orchestrator functions define function workflows using procedural code. Er zijn geen declaratieve schema's of ontwerpers nodig.No declarative schemas or designers are needed.
  • Orchestrator-functies kunnen op synchrone en asynchrone wijze andere duurzame functies aanroepen.Orchestrator functions can call other durable functions synchronously and asynchronously. Uitvoer van aangeroepen functies kan betrouwbaar worden opgeslagen in lokale variabelen.Output from called functions can be reliably saved to local variables.
  • Orchestrator-functies zijn duurzaam en betrouwbaar.Orchestrator functions are durable and reliable. De voortgang van de uitvoering wordt automatisch gecontroleerd wanneer de functie ' await ' of ' Yielden ' is.Execution progress is automatically checkpointed when the function "awaits" or "yields". Er gaat nooit lokale status verloren wanneer het proces recyclet of de VM opnieuw wordt opgestart.Local state is never lost when the process recycles or the VM reboots.
  • Orchestrator-functies kunnen langdurig worden uitgevoerd.Orchestrator functions can be long-running. De totale levens duur van een Orchestration-exemplaar kan seconden, dagen, maanden of nooit eindigend zijn.The total lifespan of an orchestration instance can be seconds, days, months, or never-ending.

In dit artikel vindt u een overzicht van Orchestrator-functies en hoe ze u kunnen helpen bij het oplossen van verschillende ontwikkel uitdagingen voor apps.This article gives you an overview of orchestrator functions and how they can help you solve various app development challenges. Als u nog niet bekend bent met de typen functies die beschikbaar zijn in een Durable Functions-app, lees dan eerst het artikel over duurzame functie typen .If you are not already familiar with the types of functions available in a Durable Functions app, read the Durable Function types article first.

Orchestration-identiteitOrchestration identity

Elk exemplaar van een indeling heeft een exemplaar-id (ook wel een exemplaar-idgenoemd).Each instance of an orchestration has an instance identifier (also known as an instance ID). Standaard is elke exemplaar-ID een automatisch gegenereerde GUID.By default, each instance ID is an autogenerated GUID. Exemplaar-Id's kunnen echter ook een door de gebruiker gegenereerde teken reeks waarde zijn.However, instance IDs can also be any user-generated string value. Elke instantie-ID van de Orchestrator moet uniek zijn binnen een Task hub.Each orchestration instance ID must be unique within a task hub.

Hier volgen enkele regels voor exemplaar-Id's:The following are some rules about instance IDs:

  • Exemplaar-Id's moeten tussen 1 en 256 tekens lang zijn.Instance IDs must be between 1 and 256 characters.
  • Exemplaar-Id's mogen niet beginnen @met.Instance IDs must not start with @.
  • Exemplaar-id's mogen geen /, \, #, of ? bevatten.Instance IDs must not contain /, \, #, or ? characters.
  • Exemplaar-Id's mogen geen besturings tekens bevatten.Instance IDs must not contain control characters.

Notitie

U wordt aangeraden om waar mogelijk automatisch gegenereerde exemplaar-Id's te gebruiken.It is generally recommended to use autogenerated instance IDs whenever possible. Door de gebruiker gegenereerde exemplaar-Id's zijn bedoeld voor scenario's waarbij een een-op-een-toewijzing is tussen een Orchestration-exemplaar en een bepaalde externe toepassingsspecifieke entiteit, zoals een aankoop order of een document.User-generated instance IDs are intended for scenarios where there is a one-to-one mapping between an orchestration instance and some external application-specific entity, like a purchase order or a document.

De instantie-ID van een indeling is een vereiste para meter voor de meeste beheer bewerkingenvan het exemplaar.An orchestration's instance ID is a required parameter for most instance management operations. Ze zijn ook belang rijk voor diagnostische gegevens, zoals het zoeken met behulp van indelings traceergegevens in Application Insights voor het oplossen van problemen of voor analyse doeleinden.They are also important for diagnostics, such as searching through orchestration tracking data in Application Insights for troubleshooting or analytics purposes. Daarom is het raadzaam om gegenereerde exemplaar-Id's op te slaan op een externe locatie (bijvoorbeeld een Data Base of in toepassings Logboeken), waar u later eenvoudig naar kunt verwijzen.For this reason, it is recommended to save generated instance IDs to some external location (for example, a database or in application logs) where they can be easily referenced later.

BetrouwbaarheidReliability

Orchestrator functioneert de uitvoerings status op betrouw bare wijze met behulp van het ontwerp patroon gebeurtenis sourcing .Orchestrator functions reliably maintain their execution state by using the event sourcing design pattern. In plaats van de huidige status van een indeling rechtstreeks op te slaan, gebruikt het duurzame taak raamwerk een archief dat alleen kan worden toegevoegd om de volledige reeks acties vast te leggen die de functie indeling neemt.Instead of directly storing the current state of an orchestration, the Durable Task Framework uses an append-only store to record the full series of actions the function orchestration takes. Een archief met alleen-lezen heeft veel voor delen ten opzichte van "dumping" van de volledige runtime status.An append-only store has many benefits compared to "dumping" the full runtime state. Voor delen zijn onder andere betere prestaties, schaal baarheid en reactie snelheid.Benefits include increased performance, scalability, and responsiveness. U krijgt ook de uiteindelijke consistentie voor transactionele gegevens en volledige controle sporen en geschiedenis.You also get eventual consistency for transactional data and full audit trails and history. De controle spoor ondersteunt betrouw bare veredelings acties.The audit trails support reliable compensating actions.

Durable Functions gebeurtenis bronnen worden op transparante wijze gebruikt.Durable Functions uses event sourcing transparently. Achter de schermen levert de await operatorC#() yield of (Java script) in een Orchestrator-functie de controle over van de Orchestrator-thread terug naar de verzender van het duurzame taak raamwerk.Behind the scenes, the await (C#) or yield (JavaScript) operator in an orchestrator function yields control of the orchestrator thread back to the Durable Task Framework dispatcher. De dispatcher voert vervolgens nieuwe acties uit die de Orchestrator-functie heeft gepland (zoals het aanroepen van een of meer onderliggende functies of het plannen van een duurzame timer) op de opslag.The dispatcher then commits any new actions that the orchestrator function scheduled (such as calling one or more child functions or scheduling a durable timer) to storage. De transparante doorvoer actie wordt toegevoegd aan de uitvoerings geschiedenis van het Orchestration-exemplaar.The transparent commit action appends to the execution history of the orchestration instance. De geschiedenis wordt opgeslagen in een opslag tabel.The history is stored in a storage table. Met de actie door voeren worden vervolgens berichten toegevoegd aan een wachtrij om de werkelijke hoeveelheid werk te plannen.The commit action then adds messages to a queue to schedule the actual work. Op dit moment kan de Orchestrator-functie uit het geheugen worden verwijderd.At this point, the orchestrator function can be unloaded from memory.

Wanneer een Orchestration-functie meer werk heeft gekregen (bijvoorbeeld wanneer er een antwoord bericht wordt ontvangen of een duurzame timer verloopt), wordt de volledige functie door de Orchestrator geactiveerd en opnieuw uitgevoerd vanaf de start om de lokale status opnieuw op te bouwen.When an orchestration function is given more work to do (for example, a response message is received or a durable timer expires), the orchestrator wakes up and re-executes the entire function from the start to rebuild the local state. Als de code tijdens het opnieuw afspelen probeert een functie aan te roepen (of andere async-werkzaamheden uit te voeren), wordt in het duurzame taak raamwerk de uitvoerings geschiedenis van de huidige indeling geraadpleegd.During the replay, if the code tries to call a function (or do any other async work), the Durable Task Framework consults the execution history of the current orchestration. Als wordt gedetecteerd dat de functie activiteit al is uitgevoerd en een resultaat oplevert, wordt het resultaat van die functie opnieuw afgespeeld en wordt de Orchestrator-code nog steeds uitgevoerd.If it finds that the activity function has already executed and yielded a result, it replays that function's result and the orchestrator code continues to run. Opnieuw afspelen gaat door totdat de functie code is voltooid of totdat het nieuwe async-werk is gepland.Replay continues until the function code is finished or until it has scheduled new async work.

Notitie

Om het patroon voor opnieuw afspelen goed en betrouwbaar te laten werken, moet Orchestrator-functie code deterministischzijn.In order for the replay pattern to work correctly and reliably, orchestrator function code must be deterministic. Zie het onderwerp functie code beperkingen van Orchestrator voor meer informatie over code beperkingen voor Orchestrator-functies.For more information about code restrictions for orchestrator functions, see the orchestrator function code constraints topic.

Notitie

Als een Orchestrator-functie logboek berichten verzendt, kan het gedrag voor opnieuw afspelen ertoe leiden dat dubbele logboek berichten worden verzonden.If an orchestrator function emits log messages, the replay behavior may cause duplicate log messages to be emitted. Raadpleeg het onderwerp over logboek registratie voor meer informatie over waarom dit gedrag optreedt en hoe u dit kunt omzeilen.See the Logging topic to learn more about why this behavior occures and how to work around it.

Orchestration-geschiedenisOrchestration history

Het gedrag gebeurtenis-sourcing van het duurzame taak raamwerk is nauw gekoppeld aan de Orchestrator-functie code die u schrijft.The event-sourcing behavior of the Durable Task Framework is closely coupled with the orchestrator function code you write. Stel dat u een Orchestrator-functie voor het koppelen van activiteiten hebt, zoals C# de volgende Orchestrator-functie:Suppose you have an activity-chaining orchestrator function, like the following C# orchestrator function:

[FunctionName("E1_HelloSequence")]
public static async Task<List<string>> Run(
    [OrchestrationTrigger] DurableOrchestrationContext context)
{
    var outputs = new List<string>();

    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "London"));

    // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
    return outputs;
}

Als u codeert in Java script, kan de Orchestrator-functie van de activiteiten keten eruitzien als de volgende voorbeeld code:If you're coding in JavaScript, your activity-chaining orchestrator function might look like the following example code:

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

module.exports = df.orchestrator(function*(context) {
    const output = [];
    output.push(yield context.df.callActivity("E1_SayHello", "Tokyo"));
    output.push(yield context.df.callActivity("E1_SayHello", "Seattle"));
    output.push(yield context.df.callActivity("E1_SayHello", "London"));

    // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
    return output;
});

Bij elke await (C#)- yield of (Java script)-instructie bewaart het duurzame taak raamwerk de uitvoerings status van de functie in een duurzame opslag back-end (doorgaans Azure Table Storage).At each await (C#) or yield (JavaScript) statement, the Durable Task Framework checkpoints the execution state of the function into some durable storage backend (typically Azure Table storage). Deze status is wat de Orchestration-geschiedeniswordt genoemd.This state is what is referred to as the orchestration history.

Geschiedenis tabelHistory table

Normaal gesp roken doet het duurzame taak raamwerk het volgende op elk controle punt:Generally speaking, the Durable Task Framework does the following at each checkpoint:

  1. Hiermee slaat u de uitvoerings geschiedenis op in Azure Storage tabellen.Saves execution history into Azure Storage tables.
  2. In-berichten voor functies die de Orchestrator wil aanroepen.Enqueues messages for functions the orchestrator wants to invoke.
  3. In berichten voor de Orchestrator zelf — , bijvoorbeeld duurzame timer berichten.Enqueues messages for the orchestrator itself — for example, durable timer messages.

Zodra het controle punt is voltooid, kan de Orchestrator-functie uit het geheugen worden verwijderd totdat er meer werk te doen.Once the checkpoint is complete, the orchestrator function is free to be removed from memory until there is more work for it to do.

Notitie

Azure Storage biedt geen transactionele garanties tussen het opslaan van gegevens in tabel opslag en wacht rijen.Azure Storage does not provide any transactional guarantees between saving data into table storage and queues. Voor het afhandelen van fouten gebruikt de Durable Functions-opslag provider uiteindelijke consistentie patronen.To handle failures, the Durable Functions storage provider uses eventual consistency patterns. Deze patronen zorgen ervoor dat er geen gegevens verloren gaan als er een storing optreedt in het midden van een controle punt.These patterns ensure that no data is lost if there is a crash or loss of connectivity in the middle of a checkpoint.

Na voltooiing ziet de geschiedenis van de eerder weer gegeven functie er ongeveer uit zoals in de volgende tabel in azure Table Storage (afgekort voor afbeeldings doeleinden):Upon completion, the history of the function shown earlier looks something like the following table in Azure Table Storage (abbreviated for illustration purposes):

PartitionKey (InstanceId)PartitionKey (InstanceId) EventTypeEventType TimestampTimestamp InvoerInput NameName ResultaatResult StatusStatus
eaee885beaee885b OrchestratorStartedOrchestratorStarted 2017-05-05T18:45:32.362Z2017-05-05T18:45:32.362Z
eaee885beaee885b ExecutionStartedExecutionStarted 2017-05-05T18:45:28.852 Z2017-05-05T18:45:28.852Z nullnull E1_HelloSequenceE1_HelloSequence
eaee885beaee885b TaskScheduledTaskScheduled 2017-05-05T18:45:32.670 Z2017-05-05T18:45:32.670Z E1_SayHelloE1_SayHello
eaee885beaee885b OrchestratorCompletedOrchestratorCompleted 2017-05-05T18:45:32.670 Z2017-05-05T18:45:32.670Z
eaee885beaee885b OrchestratorStartedOrchestratorStarted 2017-05-05T18:45:34.232 Z2017-05-05T18:45:34.232Z
eaee885beaee885b TaskCompletedTaskCompleted 2017-05-05T18:45:34.201 Z2017-05-05T18:45:34.201Z "" "Hallo Tokyo!" """"Hello Tokyo!"""
eaee885beaee885b TaskScheduledTaskScheduled 2017-05-05T18:45:34.435 Z2017-05-05T18:45:34.435Z E1_SayHelloE1_SayHello
eaee885beaee885b OrchestratorCompletedOrchestratorCompleted 2017-05-05T18:45:34.435 Z2017-05-05T18:45:34.435Z
eaee885beaee885b OrchestratorStartedOrchestratorStarted 2017-05-05T18:45:34.857 Z2017-05-05T18:45:34.857Z
eaee885beaee885b TaskCompletedTaskCompleted 2017-05-05T18:45:34.763 Z2017-05-05T18:45:34.763Z "" "Hallo Seattle!" """""Hello Seattle!"""
eaee885beaee885b TaskScheduledTaskScheduled 2017-05-05T18:45:34.857 Z2017-05-05T18:45:34.857Z E1_SayHelloE1_SayHello
eaee885beaee885b OrchestratorCompletedOrchestratorCompleted 2017-05-05T18:45:34.857 Z2017-05-05T18:45:34.857Z
eaee885beaee885b OrchestratorStartedOrchestratorStarted 2017-05-05T18:45:35.032 Z2017-05-05T18:45:35.032Z
eaee885beaee885b TaskCompletedTaskCompleted 2017-05-05T18:45:34.919 Z2017-05-05T18:45:34.919Z "" Hallo Londen! "" """"Hello London!"""
eaee885beaee885b ExecutionCompletedExecutionCompleted 2017-05-05T18:45:35.044 Z2017-05-05T18:45:35.044Z "[" "Hallo Tokyo!" "," "Hallo Seattle!" "," "Hallo Londen!" "]""[""Hello Tokyo!"",""Hello Seattle!"",""Hello London!""]" VoltooidCompleted
eaee885beaee885b OrchestratorCompletedOrchestratorCompleted 2017-05-05T18:45:35.044 Z2017-05-05T18:45:35.044Z

Enkele opmerkingen over de kolom waarden:A few notes on the column values:

  • PartitionKey: Bevat de exemplaar-ID van de indeling.PartitionKey: Contains the instance ID of the orchestration.
  • Type gebeurtenis: Vertegenwoordigt het type van de gebeurtenis.EventType: Represents the type of the event. Dit kan een van de volgende typen zijn:May be one of the following types:
    • OrchestrationStarted: De Orchestrator-functie is hervat vanaf een wachtend of wordt voor de eerste keer uitgevoerd.OrchestrationStarted: The orchestrator function resumed from an await or is running for the first time. De Timestamp kolom wordt gebruikt om de deterministische waarde voor de CurrentUtcDateTime -API in te vullen.The Timestamp column is used to populate the deterministic value for the CurrentUtcDateTime API.
    • ExecutionStarted: De Orchestrator-functie is voor de eerste keer gestart.ExecutionStarted: The orchestrator function started executing for the first time. Deze gebeurtenis bevat ook de functie-invoer in Input de kolom.This event also contains the function input in the Input column.
    • TaskScheduled: Er is een activiteit functie gepland.TaskScheduled: An activity function was scheduled. De naam van de activiteit functie wordt vastgelegd in de Name kolom.The name of the activity function is captured in the Name column.
    • TaskCompleted: De functie activity is voltooid.TaskCompleted: An activity function completed. Het resultaat van de functie bevindt Result zich in de kolom.The result of the function is in the Result column.
    • TimerCreated: Er is een duurzame Timer gemaakt.TimerCreated: A durable timer was created. De FireAt kolom bevat de geplande UTC-tijd waarop de timer verloopt.The FireAt column contains the scheduled UTC time at which the timer expires.
    • TimerFired: Een duurzame timer wordt geactiveerd.TimerFired: A durable timer fired.
    • EventRaised: Er is een externe gebeurtenis verzonden naar het Orchestrator-exemplaar.EventRaised: An external event was sent to the orchestration instance. De Name kolom bevat de naam van de gebeurtenis en de Input kolom legt de payload van de gebeurtenis vast.The Name column captures the name of the event and the Input column captures the payload of the event.
    • OrchestratorCompleted: De Orchestrator-functie is gewacht.OrchestratorCompleted: The orchestrator function awaited.
    • ContinueAsNew: De Orchestrator-functie is voltooid en opnieuw opgestart met de nieuwe status.ContinueAsNew: The orchestrator function completed and restarted itself with new state. De Result kolom bevat de waarde, die wordt gebruikt als invoer in het opnieuw gestarte exemplaar.The Result column contains the value, which is used as the input in the restarted instance.
    • ExecutionCompleted: De Orchestrator-functie is voltooid (of mislukt).ExecutionCompleted: The orchestrator function ran to completion (or failed). De uitvoer van de functie of de fout details worden opgeslagen in de Result kolom.The outputs of the function or the error details are stored in the Result column.
  • Tijds tempel: De UTC-tijds tempel van de geschiedenis gebeurtenis.Timestamp: The UTC timestamp of the history event.
  • Naam: De naam van de functie die is aangeroepen.Name: The name of the function that was invoked.
  • Invoer: De invoer in JSON-indeling van de functie.Input: The JSON-formatted input of the function.
  • Resultaat: De uitvoer van de functie; dat wil zeggen de retour waarde.Result: The output of the function; that is, its return value.

Waarschuwing

Hoewel het handig is als een hulp programma voor fout opsporing, neemt u geen afhankelijkheid op in deze tabel.While it's useful as a debugging tool, don't take any dependency on this table. Dit kan veranderen als de Durable Functions extensie wordt ontwikkeld.It may change as the Durable Functions extension evolves.

Telkens wanneer de functie wordt hervat vanuit een await (C#) of yield (Java script), voert het duurzame taak raamwerk de Orchestrator-functie opnieuw uit.Every time the function resumes from an await (C#) or yield (JavaScript), the Durable Task Framework reruns the orchestrator function from scratch. Bij elke herhaling wordt de uitvoerings geschiedenis geraadpleegd om te bepalen of de huidige async-bewerking is uitgevoerd.On each rerun, it consults the execution history to determine whether the current async operation has taken place. Als de bewerking is uitgevoerd, wordt de uitvoer van deze bewerking direct opnieuw afgespeeld en verplaatst naar de volgende await (C#) of yield (Java script).If the operation took place, the framework replays the output of that operation immediately and moves on to the next await (C#) or yield (JavaScript). Dit proces wordt voortgezet totdat de volledige geschiedenis opnieuw is afgespeeld.This process continues until the entire history has been replayed. Zodra de huidige geschiedenis opnieuw is afgespeeld, worden de lokale variabelen hersteld naar de vorige waarden.Once the current history has been replayed, the local variables will have been restored to their previous values.

Functies en patronenFeatures and patterns

In de volgende secties worden de functies en patronen van Orchestrator-functies beschreven.The next sections describe the features and patterns of orchestrator functions.

Onderliggende indelingenSub-orchestrations

Orchestrator-functies kunnen activiteiten functies aanroepen, maar ook andere Orchestrator-functies.Orchestrator functions can call activity functions, but also other orchestrator functions. U kunt bijvoorbeeld een grotere indeling van een bibliotheek van Orchestrator-functies bouwen.For example, you can build a larger orchestration out of a library of orchestrator functions. U kunt ook meerdere exemplaren van een Orchestrator-functie parallel uitvoeren.Or, you can run multiple instances of an orchestrator function in parallel.

Zie het artikel over de Subcontainment voor meer informatie en voor beelden.For more information and for examples, see the Sub-orchestrations article.

Duurzame timersDurable timers

Indelingen kunnen duurzame timers plannen voor het implementeren van vertragingen of het instellen van time-outverwerking voor asynchrone acties.Orchestrations can schedule durable timers to implement delays or to set up timeout handling on async actions. Gebruik duurzame timers in Orchestrator-functies in plaats Thread.Sleep van Task.Delay enC#() setTimeout() of setInterval() en (Java script).Use durable timers in orchestrator functions instead of Thread.Sleep and Task.Delay (C#) or setTimeout() and setInterval() (JavaScript).

Zie het artikel over de duurzame timers voor meer informatie en voor beelden.For more information and for examples, see the Durable timers article.

Externe gebeurtenissenExternal events

Orchestrator-functies kunnen wachten op externe gebeurtenissen om een Orchestrator-exemplaar bij te werken.Orchestrator functions can wait for external events to update an orchestration instance. Deze Durable Functions functie is vaak handig voor het verwerken van een menselijke interactie of andere externe retour aanroepen.This Durable Functions feature often is useful for handling a human interaction or other external callbacks.

Zie het artikel over externe gebeurtenissen voor meer informatie en voor beelden.For more information and for examples, see the External events article.

FoutafhandelingError handling

Orchestrator-functies kunnen de functies voor fout afhandeling van de programmeer taal gebruiken.Orchestrator functions can use the error-handling features of the programming language. Bestaande patronen zoals try /wordenondersteundin deindelingscodecatch .Existing patterns like try/catch are supported in orchestration code.

Orchestrator-functies kunnen ook beleid voor opnieuw proberen toevoegen aan de functies van de activiteit of de suborchestrator die ze aanroepen.Orchestrator functions can also add retry policies to the activity or sub-orchestrator functions that they call. Als een activiteit of suborchestrator-functie mislukt met een uitzonde ring, kan het opgegeven beleid voor opnieuw proberen automatisch worden vertraagd en de uitvoering tot een opgegeven aantal keren opnieuw proberen.If an activity or sub-orchestrator function fails with an exception, the specified retry policy can automatically delay and retry the execution up to a specified number of times.

Notitie

Als er sprake is van een onverwerkte uitzonde ring in een Orchestrator-functie, wordt het Orchestrator Failed -exemplaar voltooid in een status.If there is an unhandled exception in an orchestrator function, the orchestration instance will complete in a Failed state. Een Orchestrator-exemplaar kan niet opnieuw worden uitgevoerd als dit is mislukt.An orchestration instance cannot be retried once it has failed.

Zie het artikel over de fout afhandeling voor meer informatie en voor beelden.For more information and for examples, see the Error handling article.

Essentiële sectiesCritical sections

Indelings instanties worden in één thread gestroomd, zodat u zich geen zorgen hoeft te maken over race voorwaarden binnen een indeling.Orchestration instances are single-threaded so it isn't necessary to worry about race conditions within an orchestration. Race conditions zijn echter mogelijk wanneer er met de integratie met externe systemen wordt gecommuniceerd.However, race conditions are possible when orchestrations interact with external systems. Voor het beperken van race-voor waarden bij interactie met externe systemen, kunnen Orchestrator-functies essentiële secties definiëren LockAsync met behulp van een methode in .net.To mitigate race conditions when interacting with external systems, orchestrator functions can define critical sections using a LockAsync method in .NET.

De volgende voorbeeld code toont een Orchestrator-functie die een kritieke sectie definieert.The following sample code shows an orchestrator function that defines a critical section. De sectie kritiek wordt met behulp LockAsync van de-methode ingevoerd.It enters the critical section using the LockAsync method. Voor deze methode moet een of meer verwijzingen naar een duurzame entiteitworden door gegeven, wat blijvend de vergrendelings status beheert.This method requires passing one or more references to a Durable Entity, which durably manages the lock state. In slechts één exemplaar van deze indeling kan de code in de sectie kritiek per keer worden uitgevoerd.Only a single instance of this orchestration can execute the code in the critical section at a time.

[FunctionName("Synchronize")]
public static async Task Synchronize(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var lockId = new EntityId("LockEntity", "MyLockIdentifier");
    using (await context.LockAsync(lockId))
    {
        // critical section - only one orchestration can enter at a time
    }
}

Het LockAsync verwerft de duurzame vergren deling (en) IDisposable en retourneert een die het kritieke gedeelte afbreekt wanneer het wordt verwijderd.The LockAsync acquires the durable lock(s) and returns an IDisposable that ends the critical section when disposed. Dit IDisposable resultaat kan worden gebruikt in combi natie using met een blok om een syntaxis weergave van de sectie kritiek te verkrijgen.This IDisposable result can be used together with a using block to get a syntactic representation of the critical section. Wanneer een Orchestrator-functie een kritieke sectie invoert, kan slechts één exemplaar dat code blok uitvoeren.When an orchestrator function enters a critical section, only one instance can execute that block of code. Alle andere instanties die proberen de sectie kritiek in te voeren, worden geblokkeerd totdat het vorige exemplaar de sectie kritiek verlaat.Any other instances that try to enter the critical section will be blocked until the previous instance exits the critical section.

De functie essentiële sectie is ook handig voor het coördineren van wijzigingen aan duurzame entiteiten.The critical section feature is also useful for coordinating changes to durable entities. Zie het onderwerp ' entiteits coördinatie ' in duurzame entiteiten voor meer informatie over kritieke secties.For more information about critical sections, see the Durable entities "Entity coordination" topic.

Notitie

Essentiële secties zijn beschikbaar in Durable Functions 2,0 en hoger.Critical sections are available in Durable Functions 2.0 and above. Op dit moment wordt deze functie alleen geïmplementeerd door .NET-integratie.Currently, only .NET orchestrations implement this feature.

HTTP-eind punten aanroepenCalling HTTP endpoints

Orchestrator-functies zijn niet toegestaan voor I/O, zoals beschreven in de functie code beperkingen van Orchestrator.Orchestrator functions aren't permitted to do I/O, as described in orchestrator function code constraints. De gebruikelijke tijdelijke oplossing voor deze beperking is het verpakken van code die I/O in een activiteit functie moet uitvoeren.The typical workaround for this limitation is to wrap any code that needs to do I/O in an activity function. Integraties die communiceren met externe systemen gebruiken vaak activiteit functies om HTTP-aanroepen te maken en het resultaat te retour neren naar de indeling.Orchestrations that interact with external systems frequently use activity functions to make HTTP calls and return the result to the orchestration.

Om dit algemene patroon te vereenvoudigen, kunnen Orchestrator-functies de CallHttpAsync methode in .net gebruiken om rechtstreeks http-api's aan te roepen.To simplify this common pattern, orchestrator functions can use the CallHttpAsync method in .NET to invoke HTTP APIs directly. Naast het ondersteunen van basis patronen CallHttpAsync voor aanvraag/antwoord ondersteunt automatische verwerking van veelvoorkomende asynchrone http 202-polling patronen en wordt ook verificatie met externe services met beheerde identiteitenondersteund.In addition to supporting basic request/response patterns, CallHttpAsync supports automatic handling of common async HTTP 202 polling patterns, and also supports authentication with external services using Managed Identities.

[FunctionName("CheckSiteAvailable")]
public static async Task CheckSiteAvailable(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    Uri url = context.GetInput<Uri>();

    // Makes an HTTP GET request to the specified endpoint
    DurableHttpResponse response = 
        await context.CallHttpAsync(HttpMethod.Get, url);

    if (response.StatusCode >= 400)
    {
        // handling of error codes goes here
    }
}

Zie het artikel http-functies voor meer informatie en voor meer gedetailleerde voor beelden.For more information and for detailed examples, see the HTTP features article.

Notitie

Het aanroepen van HTTP-eind punten rechtstreeks vanuit Orchestrator-functies is beschikbaar in Durable Functions 2,0 en hoger.Calling HTTP endpoints directly from orchestrator functions is available in Durable Functions 2.0 and above. Op dit moment wordt deze functie alleen geïmplementeerd door .NET-integratie.Currently, only .NET orchestrations implement this feature.

Meerdere para meters door gevenPassing multiple parameters

Het is niet mogelijk om rechtstreeks meerdere para meters door te geven aan een activiteit functie.It isn't possible to pass multiple parameters to an activity function directly. De aanbeveling is om een matrix met objecten door te geven of om ValueTuples -objecten in .net te gebruiken.The recommendation is to pass in an array of objects or to use ValueTuples objects in .NET.

In het volgende voor beeld worden nieuwe functies van ValueTuples gebruikt die zijn toegevoegd met C# 7:The following sample is using new features of ValueTuples added with C# 7:

[FunctionName("GetCourseRecommendations")]
public static async Task<object> RunOrchestrator(
    [OrchestrationTrigger] DurableOrchestrationContext context)
{
    string major = "ComputerScience";
    int universityYear = context.GetInput<int>();

    object courseRecommendations = await context.CallActivityAsync<object>(
        "CourseRecommendations",
        (major, universityYear));
    return courseRecommendations;
}

[FunctionName("CourseRecommendations")]
public static async Task<object> Mapper([ActivityTrigger] DurableActivityContext inputs)
{
    // parse input for student's major and year in university
    (string Major, int UniversityYear) studentInfo = inputs.GetInput<(string, int)>();

    // retrieve and return course recommendations by major and university year
    return new
    {
        major = studentInfo.Major,
        universityYear = studentInfo.UniversityYear,
        recommendedCourses = new []
        {
            "Introduction to .NET Programming",
            "Introduction to Linux",
            "Becoming an Entrepreneur"
        }
    };
}

Volgende stappenNext steps