This document provides a guide to debugging asynchronous code in .NET. It discusses how asynchronous code uses an "async logical call stack" instead of physical threads. It demonstrates how the debugger can show this async call stack to understand the flow of async methods. It also shows how tasks, threads, and exceptions are handled in async code and tips for writing asynchronous code that is easier to debug.

1. xedotnet.org
Async Debugging
A Practical Guide to survive !
Mirco Vanini
@MircoVanini

2. Agenda
• Sync To Async Code
• Async state machine
• Async logical call stack (chain of continuations)
• Debug
• Parallel Stacks for Tasks and Theads
• Tasks Window
• Threads Window
• Parallel Watch
• Rethrown Exceptions
• Snapshot on Exception (IntelliTrace -> Historical Debugger)
• Async Guidance
• Q&A

3. Start plain and simple
public double GetTotalOderedByCustomer(string customer)
{
double total = 0;
foreach (var order in GetOrdersByCustomer(customer))
{
var details = order.GetOrderDetails();
total += details.Sum(d => d.Quantity * d.UnitPrice);
}
return total;
}
Everythings is frozen and
we are doomed !
…How about adding
some async/await ?

4. Compiler generated code
public async Task<double> GetTotalOderedByCustomerAsync(string customer)
{
double total = 0;
foreach (var order in await GetOrdersByCustomerAsync(customer))
{
var details = await order.GetOrderDetailsAsync();
total += details.Sum(d => d.Quantity * d.UnitPrice);
}
return total;
}
[AsyncStateMachine(typeof(<GetTotalOderedByCustomerAsync>d__0))]
[DebuggerStepThrough]
public Task<double> GetTotalOderedByCustomerAsync(string customer)
{
<GetTotalOderedByCustomerAsync>d__0 stateMachine = new
<GetTotalOderedByCustomerAsync>d__0();
stateMachine.<>t__builder = AsyncTaskMethodBuilder<double>.Create();
stateMachine.<>4__this = this;
stateMachine.customer = customer;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
SharpLab.io

5. Compiler generated code
public async Task<double>
GetTotalOderedByCustomerAsync(string customer)
{
double total = 0;
foreach (var order in await
GetOrdersByCustomerAsync(customer))
{
var details = await order.GetOrderDetailsAsync();
total += details.Sum(d => d.Quantity *
d.UnitPrice);
}
return total;
}
[CompilerGenerated]
private sealed class <GetTotalOderedByCustomerAsync>d__0 : IAsyncStateMachine
{
public int <>1__state;
public AsyncTaskMethodBuilder<double> <>t__builder;
// local variables !
public string customer;
public DataService <>4__this;
private double <total>5__1;
...
// awaiters !
private TaskAwaiter<IEnumerable<Order>> <>u__1;
private TaskAwaiter<IEnumerable<OrderDetail>> <>u__2;
private void MoveNext()
{
int num = <>1__state;
double result;
try
{
TaskAwaiter<IEnumerable<Order>> awaiter;
if (num != 0)
{
if (num == 1)
{
goto IL_00c4;
}
<total>5__1 = 0.0;
awaiter = <>4__this.GetOrdersByCustomerAsync(customer).GetAwaiter();
SharpLab.io

6. Performance ?

7. Without Await | I/O-bound vs CPU-bound
public Task<double> GetTotalOderedByCustomerWithoutAwait(string customer)
{
ConcurrentBag<double> totals = new ConcurrentBag<double>();
Task<IEnumerable<Order>> fetchOrders = Task.Run(() => GetOrdersByCustomer(customer));
Task matchOrders = fetchOrders.ContinueWith(t =>
{
List<Task> matchTasks = new();
foreach (var order in t.Result)
{
Task<IEnumerable<OrderDetail>> detailTask = Task.Run(() => order.GetOrderDetails());
Task matchDetail = detailTask.ContinueWith(t1 =>
{
totals.Add(t1.Result.Sum(d => d.Quantity * d.UnitPrice));
}, TaskContinuationOptions.AttachedToParent);
matchTasks.Add(matchDetail);
}
return Task.WhenAll(matchTasks);
});
return matchOrders.ContinueWith(_ => totals.Sum(p => p));
}

8. Async code | call stack
Debug > Windows > Call stack | Debug > Windows > Threads > main thread)

9. Async code | call stack
Debug > Windows > Parallel Stacks > Threads

10. So how do we debug this ?
Async logical call stack
The first thing used while debugging are «call stacks»
Call stack show caller -> callee relation !
We also need call stack fro async code – such as «async call stacks»

11. Async vs sync stacks
SYNC stacks ASYNC stacks
Code is currently running on a thread Code may not be running anywhere or
scheduled to run in the future
Hence – Physical stacks Virtual or logical stacks. Not tied to a single
(or any) thread.
Locals are allocated on stack memory Local are stashed in “state machines” (internal
compiler generated helper structures)

12. Async call stacks
Task #1
GetOrderByCustomerAsync()
m_continuation
public async Task<double> GetTotalOderedByCustomerAsync(string customer)
{
double total = 0;
foreach (var order in await GetOrdersByCustomerAsync(customer))
{
var details = await order.GetOrderDetailsAsync();
total += details.Sum(d => d.Quantity * d.UnitPrice);
}
return total;
}
Task #2
GetOrderDetailsAsync()
m_continuation
Here the await keyword adds the next line of GetTotalOrderedByCutomerAsync
as a continuation to GetOrdersByCustomerAsync.
The Task of GetOderDetailsAsync store a reference to the next line of
GetTotalOrderedByCutomerAsync to invoke when done.

13. Async call stacks
Task #1
GetOrderByCustomerAsync()
m_continuation
Task #2
GetOrderDetailsAsync()
m_continuation
The debugger walks through this chain of references – to get a chain of
continuations
Async Logical Stacks
GetOrderDetailsAsync
GetOrderByCustomerAsync
The chian of continuations is what we call async call stack

14. Async call stacks
Task #1
GetOrderByCustomerAsync()
m_continuation
Task #2
GetOrderDetailsAsync()
m_continuation
Async stack are a continuation stack
This may be quite different from the stack or context of where the task
was created – that is, the creation stack
Task #N
...
m_continuation

15. Creation Stack vs Continuation Stack
Note that TakeABreak is not part of the async call stack
Async Task
> Task.Delay(…)
DoSomething(…)
public Task TakeABreak()
{
return Task.Delay(1000);
}
public async Task DoSomething()
{
foreach (var order in orders)
{
Task pause = TakeABreak();
details = await order.GetOrderDetails();
await pause;
}
}
??? TakeABreak(…) ???

16. Creation Stack vs Continuation Stack
Sync call stack are also really just continuation stack: the creation (call) and
continuation are the same
In async, control goes to whoever awaits (or waits) the current async code,
which may be different from the scope or method in which it was called.
Keep that in mind while async debugging – especially while using
TaskCompletitionSource<T> [used for APM (Asynchronous Programming Model)
or EAP (Event-Based Asynchronous Pattern)].

17. EAP sample
public static class StoryboardHelper
{
public static Task RunAsync(this Storyboard storyboard)
{
var tcs = new TaskCompletionSource<object>();
EventHandler<object> completion = null;
completion = (sender, args) =>
{
storyboard.Completed -= completion;
tcs.SetResult(null);
};
storyboard.Completed += completion;
storyboard.Begin();
return tcs.Task;
}
}
…
await myStoryboard.RunAsync();

18. Async call stacks
public async Task DoSomething()
{
List<Task> tasks = new List<Task>();
foreach (var order in orders)
{
tasks.Add(order.GetOrderDetailsAsync());
}
await Task.WhenAll(tasks);
}
Task #1
GetOrderDetailsAsync()
m_continuation
Task #2
GetOrderDetailsAsync()
m_continuation
Task #2
GetOrderDetailsAsync()
m_continuation
Task #1
DoSomething()
m_continuation

19. Demo | Parallel Stacks for Tasks and Theads

20. Demo | Tasks Window – Threads Window

21. Demo | Rethrown Exceptions / Snapshot on Exception

22. Async Code Tips
• Async void
• Prefer Task.FromResult over Task.Run for pre-computed or trivially computed data
• Avoid using Task.Run for long running work that blocks the thread
• Avoid using Task.Result and Task.Wait
• Prefer await over ContinueWith
• Always create TaskCompletionSource<T> with TaskCreationOptions.RunContinuationsAsynchronously
• Always dispose CancellationTokenSource(s) used for timeouts
• Always flow CancellationToken(s) to APIs that take a CancellationToken
• Cancelling uncancellable operations
• Always call FlushAsync on StreamWriter(s) or Stream(s) before calling Dispose
• Prefer async/await over directly returning Task
• ConfigureAwait
The first debugging step is writing good code !
AsyncGuidance

23. Q&A
.NET
your platform for building anything
Mirco Vanini
Microsoft® MVP Windows Development
myContactInfo:
{
”e-mail”:“mirco.vanini@proxsoft.it”,
“web”: “www.proxsoft.it”,
“twitter”: “@MircoVanini”
}