This document discusses the evolution of asynchronous and parallel programming in C# code. It begins by covering synchronous code examples. It then covers asynchronous programming using async/await. Examples of parallel programming by starting multiple asynchronous tasks concurrently are also provided. The document then introduces Azure Durable Functions as a way to distribute asynchronous and parallel code across multiple servers. It provides examples of common Durable Functions patterns like chaining functions, fan-out/fan-in, external events, and timers. Overall it shows how programming models have evolved from synchronous to asynchronous to parallel and now to distributed using serverless platforms like Durable Functions.

1. Azure Durable
Funkiness
@stuartleeks
Web and Cloud geek @ Microsoft

2. The Evolution of
Code
C# Edition

3. Sync -> Async -> Parallel -> Distributed

4. Synchronous
void DemoSync()
{
try // try/catch and using work nicely
{
DoStuff();
DoMoreStuff();
DoEvenMoreStuff();
}
catch (Exception ex)
{
// Handle exception
}
}

5. Asynchronous
async Task<string[]> DemoAsync()
{
try // try/catch and using work nicely
{
var x = await DoStuffAsync();
var y = await DoMoreStuffAsync();
var z = await DoEvenMoreStuffAsync();
return new[] { x, y, z };
}
catch (Exception ex)
{
// Handle exception
}
}

6. Asynchronous
async Task<string[]> DemoAsync()
{
try // try/catch and using work nicely
{
var x = await DoStuffAsync();
var y = await DoMoreStuffAsync();
var z = await DoEvenMoreStuffAsync();
return new[] { x, y, z };
}
catch (Exception ex)
{
// Handle exception
}
}

7. Asynchronous
async Task<string[]> Demo2Async()
{
try // try/catch and using work nicely
{
var taskx = DoStuffAsync();
var x = await taskx;
var y = await DoMoreStuffAsync();
var z = await DoEvenMoreStuffAsync();
return new[] { x, y, z };
}
catch (Exception ex)
{
// Handle exception
}
}

8. Parallel
async Task<string> Demo1Parallel()
{
try // try/catch and using work nicely
{
var task1 = DoStuffAsync();
var task2 = DoMoreStuffAsync();
await task1;
await task2;
return await DoStuffAfterOtherStuffAsync(task1.Result, task2.Result);
}
catch (Exception ex)
{
// Handle exception
}
}

9. Parallel
async Task<string> DemoParallel()
{
try // try/catch and using work nicely
{
var task1 = DoStuffAsync();
var task2 = DoMoreStuffAsync();
await Task.WhenAll(task1, task2);
return await DoStuffAfterOtherStuffAsync(task1.Result, task2.Result);
}
catch (Exception ex)
{
// Handle exception
}
}

10. Sync -> Async -> Parallel

11. Azure Durable Functions

12. Sync -> Async -> Parallel -> Distributed

13. Distributed - Chaining
async Task<string[]> Run1(DurableOrchestrationContext ctx)
{
try // try/catch and using work nicely
{
var x = await ctx.CallActivityAsync<string>("DoStuffAsync");
var y = await ctx.CallActivityAsync<string>("DoMoreStuffAsync");
var z = await ctx.CallActivityAsync<string>("DoEvenMoreStuffAsync");
return new[] { x, y, z };
}
catch (Exception)
{
// Handle exception
}
}

14. Distributed – Fan-out/Fan-in
public static async Task<string> Run2(DurableOrchestrationContext ctx)
{
try // try/catch and using work nicely
{
var task1 = ctx.CallActivityAsync<string>("DoStuffASync");
var task2 = ctx.CallActivityAsync<string>("DoMoreStuffASync");
await Task.WhenAll(task1, task2);
return await ctx.CallActivityAsync<string>("DoStuffAfterOtherStuffAsync", task1.Result, task2.Result);
}
catch (Exception)
{
// Handle exception
}
}

15. Durable Functions - Patterns

16. Distributed – Trigger function
[FunctionName("Start")]
public static async Task<HttpResponseMessage> Start(
[HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestMessage request,
[OrchestrationClient] DurableOrchestrationClient starter)
{
var instanceId = await starter.StartNewAsync("WaitForApproval");
return starter.CreateCheckStatusResponse(request, instanceId);
}

17. Distributed – Timers and External Events
[FunctionName(“WaitForApproval")]
public static async Task<string> WaitForApproval(DurableOrchestrationContext ctx)
{
var approvedTask = ctx.WaitForExternalEvent<string>("Approved");
var cts = new CancellationTokenSource();
var timeoutTask = context.CreateTimer(context.CurrentUtcDateTime.AddMinutes(5), cts.Token);
var winningTask = await Task.WhenAny(approvedTask, timeoutTask);
if (winningTask == timeoutTask)
await ctx.CallActivityAsync<string>(“Escalate");
else
await ctx.CallActivityAsync<string>(“Success");
}

18. Distributed – Timers and External Events
[FunctionName(“Approve")]
public static async Task<HttpResponseMessage> Approve(
[HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestMessage request,
[OrchestrationClient] DurableOrchestrationClient starter)
{
var instanceId = request.RequestUri.ParseQueryString()["instanceId"];
return starter.RaiseEventAsync(instanceId, "Approved", "Stuart Leeks");
}

19. Durable Functions - Patterns

20. Durable Functions
http://aka.ms/durablefunctions

21. The Evolution of
Code
C# Edition
With Azure Functions
Durable Functions
http://aka.ms/durablefunctions