Durable Functions in Azure facilitate complex orchestrations of long-running tasks by simplifying function coordination, enabling easy communication, and maintaining local state without the need for JSON schemas or designers. The document outlines examples of orchestrator functions for sequential and parallel execution of tasks, handling errors, and managing approvals with timeouts. Key advantages include cost-effective scaling and automatic state management during sleep periods.

2. Durable Functions – Orchestrators for Azure
Functions
Reduce ComplexitySimplify
Enable Long Running FunctionsEnable
Orchestrate FunctionsCoordinate

3. Why do we need “Durable Functions”
Long Running &
Local State
01
Simplify
Function
Coordination
02
Easy Function
Communication
03
Code-Only
04

4. What is Durable Functions?
Automatic Save of
Local State
03
No JSON
schemas,
No designer!
01
Sync & Async
Functions Calls
02

5. F1 F2 F3 F4

7. // calls functions in sequence
public static async Task<object> Run(DurableOrchestrationContext ctx)
{
try
{
var x = await ctx.CallFunctionAsync("F1");
var y = await ctx.CallFunctionAsync("F2", x);
var z = await ctx.CallFunctionAsync("F3", y);
return await ctx.CallFunctionAsync("F4", z);
}
catch (Exception)
{
// global error handling/compensation goes here
}
}

8. F1
F2
F3

10. public static async Task Run(DurableOrchestrationContext ctx)
{
var parallelTasks = new List<Task<int>>();
// get a list of N work items to process in parallel
object[] workBatch = await ctx.CallFunctionAsync<object[]>("F1");
for (int i = 0; i < workBatch.Length; i++)
{
Task<int> task = ctx.CallFunctionAsync<int>("F2", workBatch[i]);
parallelTasks.Add(task);
}
await Task.WhenAll(parallelTasks);
// aggregate all N outputs and send result to F3
int sum = parallelTasks.Sum(t => t.Result);
await ctx.CallFunctionAsync("F3", sum);
}

11. Request Approval
Function
Escalate Function
Process Approval
Function

12. public static async Task Run(DurableOrchestrationContext ctx)
{
await ctx.CallFunctionAsync<object[]>("RequestApproval");
using (var timeoutCts = new CancellationTokenSource())
{
DateTime dueTime = ctx.CurrentUtcDateTime.AddHours(72);
Task durableTimeout = ctx.CreateTimer(dueTime, 0, cts.Token);
Task<bool> approvalEvent = ctx.WaitForExternalEvent<bool>("ApprovalEvent");
if (approvalEvent == await Task.WhenAny(approvalEvent, durableTimeout))
{
timeoutCts.Cancel();
await ctx.CallFunctionAsync("HandleApproval", approvalEvent.Result);
}
else
{
await ctx.CallFunctionAsync("Escalate");
}
}
}

13. Worker
Worker
Worker
Worker
Worker
Stateful/Partitioned
Stateless
Control Queue(s)
Triggers orchestrator
function execution
Work Item Queue
Triggers activity function execution
History & Instance Tables

14. Key Takeaways - Orchestrator functions
Code Stateful Durable
When
sleeping, not
billed
Automatically
wake up
Scalable