The document discusses asynchronous programming using async and await in C#. It begins by explaining what asynchronous programming is and why it is useful for improving app responsiveness and simplifying asynchronous code. It then describes how async and await works by generating state machines and using continuation tasks. The document covers some gotchas with async code as well as best practices like naming conventions. It provides references for further reading on asynchronous patterns, tasks, and unit testing asynchronous code.

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!