1. End-to-End Async and Await
Vince Fabro
Cardinal Solutions
Practice Manager, Enterprise App Dev
@vfabro

2. Agenda
• What is Async?
• Why bother?
• How does this work?
• Gotchas
• Best Practices & More Details
• Next Steps

3. Agenda
• What is Async?
• Why bother?
• How does this work?
• Gotchas
• Best Practices & More Details
• Next Steps

4. What is Async?
• C# 5.0 and .NET 4.5
• async and await keywords
• Asynchronous programming for the
masses!

5. What is Async?
• Asynchronous == Parallel?
• Asynchronous == Multithreaded?
• Asynchronous == Easy?

6. Agenda
• What is Async?
• Why bother?
• How does this work?
• Gotchas
• Best Practices & More Details
• Next Steps

7. Why bother?
• Improve app responsiveness
• Simplify asynchronous programming
 more approachable
Simpler /
More approachable than what?

8. Asynchrony the good old way
• [… as opposed to the much worse older ways]
• APM and EAP
• APM – Asynchronous Programming Model
– http://msdn.microsoft.com/en-us/library/ms228963%28v=vs.110%29.aspx
– http://msdn.microsoft.com/en-us/magazine/cc163467.aspx
• EAP – Event-based Asynchronous Pattern
– http://msdn.microsoft.com/en-us/library/wewwczdw%28v=vs.110%29.aspx

9. Asynchronous Programming Model
IAsyncResult result = Dns.BeginGetHostEntry(
args[0], null, null);
// Poll for completion information.
while (result.IsCompleted != true)
{
…
}
// EndGetHostByName blocks until complete.
IPHostEntry host = Dns.EndGetHostEntry(result);
string[] aliases = host.Aliases;
.NET2.0+

10. Event-based Asynchronous Pattern
private SoundPlayer player;
private void InitializeSound()
{
// Create an instance of the SoundPlayer class.
player = new SoundPlayer();
// Listen for the LoadCompleted event.
player.LoadCompleted +=
new AsyncCompletedEventHandler(player_LoadCompleted);
player.SoundLocation = filepathTextbox.Text;
player.Play();
}
private void player_LoadCompleted(
object sender, AsyncCompletedEventArgs e) { }
.NET2.0+

11. Supplanted by the TPL
• Both APM and EAP 
– “This pattern is no longer recommended for
new development”
• TPL  Task Parallel Library
– http://msdn.microsoft.com/en-
us/library/dd460693%28v=vs.110%29.aspx
.NET4.0+

12. Supplanted by the TPL
.NET4.0+

13. Supplanted by the TPL
.NET4.0+

14. Supplanted by the TPL
Parallel.ForEach(sourceCollection, item => Process(item));
Parallel.Invoke(() => DoSomeWork(), () => DoSomeOtherWork());
// Create a task and supply a user delegate
Task taskA = new Task( () =>
Console.WriteLine("Hello from taskA."));
// Start the task.
taskA.Start();
// Output a message from the calling thread.
Console.WriteLine("Hello from thread '{0}'.",
Thread.CurrentThread.Name);
taskA.Wait();
.NET4.0+

15. The New Hotness!
• TAP – Task-based Asynchronous Pattern
• async and await
• So… Why bother?
– Simpler than APM and EAP
– Simpler than raw TPL
Builds on the TPL
.NET4.5

16. Task-based Asynchronous Pattern
private async Task<int> AccessTheWebAsync()
{
HttpClient client = new HttpClient();
string urlContents = await client.GetStringAsync(
"http://msdn.microsoft.com");
return urlContents.Length;
}

17. Agenda
• What is Async?
• Why bother?
• How does this work?
• Gotchas
• Best Practices & More Details
• Next Steps

18. How does this work?

20. Task-based Asynchronous Pattern
private async Task<int> AccessTheWebAsync()
{
HttpClient client = new HttpClient();
string urlContents = await client.GetStringAsync(
"http://msdn.microsoft.com");
return urlContents.Length;
}
1. Before await
2. Await Task
3. Post await
2. “Awaitable”
3. Continuation
0. For compiler

21. How does this work?

22. Gimme the Code!
void IAsyncStateMachine.MoveNext()
{
string result = null;
try
{
int num = state;
//if (!Stop)
if (num != -3)
{
TaskAwaiter<string> taskAwaiter;
// Machine starts with num=-1 so we enter
if (num != 0)
{
// First (+ initial) state code, run code before await is invoked
httpClient = new HttpClient();
Debug.WriteLine("before await");
// A task is invoked
taskAwaiter = httpClient.GetStringAsync(url).GetAwaiter();

23. Gimme the Code!
Whole
Lotta
Code!

24. How does it work?
• Generates a state machine for every
async call
• SynchronizationContext
• Continuation Tasks

25. How does it work?
• SynchronizationContext
– Provides a way to queue a unit of work to a
context, not to a specific thread
– Keeps a queue and count of work to do
– Every thread has a current context
– http://msdn.microsoft.com/en-us/magazine/gg598924.aspx

26. How does it work?
• SynchronizationContext Implementations:
– WindowsFormsSynchronizationContext
– DispatcherSynchronizationContext
• WPF and SilverLight
– WinRTSynchronizationContext
– AspNetSynchronizationContext
• ASP.NET thread pool
– Default SynchronizationContext
• ThreadPool

27. How does it work?
• Continuation Tasks
– On completion of one task, invoke another
// The antecedent task. Can also be created with Task.Factory.StartNew.
Task<DayOfWeek> taskA = new Task<DayOfWeek>(() => DateTime.Today.DayOfWeek);
// The continuation. Its delegate takes the antecedent task
// as an argument and can return a different type.
Task<string> continuation = taskA.ContinueWith((antecedent) =>
{
return String.Format("Today is {0}.", antecedent.Result);
});
// Start the antecedent.
taskA.Start();
// Use the contuation's result.
Console.WriteLine(continuation.Result);

28. Task-based Asynchronous Pattern
private async Task<int> AccessTheWebAsync()
{
HttpClient client = new HttpClient();
string urlContents = await client.GetStringAsync(
"http://msdn.microsoft.com");
return urlContents.Length;
}
1. Before await
2. Await Task
3. Post await
2. “Awaitable”
3. Continuation
0. For compiler

29. Agenda
• What is Async?
• Why bother?
• How does this work?
• Gotchas
• Best Practices & More Details
• Next Steps

30. Gotchas…
• Requirements
– You must use the async keyword to await
– void events may need marked with async
public void Blah  public async Task BlahAsync
• Limitations
– You cannot declare ref or out parameters on
an async method

31. Gotchas…
• When you can’t await async methods
– Inside catch and finally blocks
– Inside properties
– Inside a lock block
– In an unsafe region
– Within most portions of a LINQ query

32. Gotchas…
• Deadlock and Race conditions, oh my!
var delayTask = DelayAsync();
delayTask.Wait();

33. Agenda
• What is Async?
• Why bother?
• How does this work?
• Gotchas
• Best Practices & More
Details
• Next Steps

34. Best Practices & More Details
• Name async methods BlahBlahAsync
• End to end
– Cascading Async

35. Best Practices & More Details
• Configuring ASP.NET
– Increase App Pool’s queue limit
– AsyncTimeout
• Async in ASP.NET page lifecycle events
%@Page ... Async=“true” %
RegisterAsyncTask(
new PageAsyncTask(GetDataAsync));
http://www.asp.net/mvc/tutorials/mvc-4/using-asynchronous-methods-in-aspnet-mvc-4
http://www.asp.net/web-forms/tutorials/aspnet-45/using-asynchronous-methods-in-aspnet-45

36. Best Practices & More Details
• Unit testing
– You can test async methods
[TestMethod]
public async Task GivenBlah…() {
var result = await testClass.DoSomethingAsync();
}
– You can mock async method calls
mockDownloadContent.Setup(x => x.DoSomethingAsync())
.Returns(Task.FromResult<string>(expectedResult));

37. Best Practices & More Details
• Entity Framework 6
– ApplicationDbContext
await context.Categories.Include(
c => c.Products).LoadAsync();
int savedCount =
await context.SaveChangesAsync();
– QueryableExtensions
var employeeCount = await query.CountAsync();
var firstEmployee = await query.FirstAsync();
https://entityframework.codeplex.com/wikipage?title=Task-based%20Asynchronous%20Pattern%20support%20in%20EF

38. Best Practices & More Details
• Executing tasks in parallel
await Task1Async();
await Task2Async();
await Task3Async();
await Task.WhenAll(Task1Async(),
Task2Async(),
Task3Async());

39. Best Practices & More Details
• Death by a thousand cuts
– Batch up async calls
• ConfigureAwait(false)
http://msdn.microsoft.com/en-us/magazine/hh456402.aspx

40. Best Practices & More Details
• await Task.Yield()
http://msdn.microsoft.com/en-us/library/hh873173%28v=vs.110%29.aspx
• Task cancellation
http://msdn.microsoft.com/en-us/library/jj155759.aspx
• Reporting progress
http://simonsdotnet.wordpress.com/2013/10/11/updating-your-ui-asynchronously-
part-3-reporting-progress/

41. Agenda
• What is Async?
• Why bother?
• How does this work?
• Gotchas
• Best Practices
• Next Steps

42. References
• Asynchronous Programming Patterns
– http://msdn.microsoft.com/en-us/library/wewwczdw%28v=vs.110%29.aspx
• Async and await FAQ
• Steven Cleary’s blog
• Channel 9
• Stephen Toub: The Costs of Async
– http://msdn.microsoft.com/en-us/magazine/hh456402.aspx

43. Thank You!