1. C# 5 async & await Justin Lee Software Development Consultant Community Technology Update 2011 25th June 2011

2. Concurrency is… about running or appearing to run two things at once, through cooperative or pre-emptive multitasking or multicore. Good reasons to use concurrency: for the CPU-bound multicore computational kernel (e.g. codecs); for a server handling requests from different processes/machines; to “bet on more than one horse” and use whichever was fastest.

3. Asynchrony is… about results that are delayed, and yielding control while awaiting them (co-operative multitasking). Good reasons to use asynchrony: for overall control / coordination structure of a program; for UI responsiveness; for IO- and network-bound code; for coordinating your CPU-bound multicore computational kernel.

4. “A waiter’s job is to wait on a table until the patrons have finished their meal.If you want to serve two tables concurrently, you must hire two waiters.”

5. Demo Converting from synchronous, to asynchronous, to using await

6. UIthread IOCP thread asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } How the demo actually worked

7. UIthread [1/12] A button-click arrives on the UI queue IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click

8. UIthread [2/12] Invoke some functions; get back “dTask” from the API IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click dTask

9. UIthread [3/12] “await task” assigns a continuation and returns task IOCP thread asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); var task = web.DownTaskAsync("http://netflix.com"); varrss = await task; var movies = XElement.Parse(rss).<story>.<description>; return movies; } async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } Click task dTask dTask»ui.Post{Κ1} Κ1:

10. UIthread [4/12] “await task” assigns a continuation and returns IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click task task »ui.Post{Κ2} dTask»ui.Post{Κ1} Κ1: Κ2:

11. UIthread [5/12] Network packet arrives with data IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click task »ui.Post{Κ2} dTask»ui.Post{Κ1} rss Κ1: Κ2:

12. UIthread [6/12] Invoke dTask’scontinuation with that data IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click task »ui.Post{Κ2} dTask»ui.Post{Κ1} rss ui.Post{Κ1(rss)} Κ1: Κ2:

13. UIthread [7/12] Continuation is a “Post”, i.e. addition to the UI queue IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click task »ui.Post{Κ2} rss ui.Post{Κ1(rss)} Κ1: K1(rss) Κ2:

14. UIthread [8/12] UI thread executes K1, giving a result to the “await” IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click task »ui.Post{Κ2} rss ui.Post{Κ1(rss)} Κ1: K1(rss) Κ2:

15. UIthread [9/12] “return movies” will signal completion of task IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click task »ui.Post{Κ2} rss ui.Post{Κ1(rss)} Κ1: K1(rss) Κ2:

16. UIthread [10/12] Invoke task’s continuation with data (by posting to UI queue) IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click task »ui.Post{Κ2} rss ui.Post{Κ1(rss)} Κ1: K1(rss) ui.Post(Κ2(movie)) Κ2: K2(movie)

17. UIthread [11/12] Return from handling the K1 continuation IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click rss ui.Post{Κ1(rss)} Κ1: K1(rss) ui.Post(Κ2(movie)) Κ2: K2(movie)

18. UIthread [12/12] UI thread executes K2, giving a result to the “await” IOCP thread async voidSearchButtonClick() {vartask = QueryMoviesAsync(); varm = awaittask; textBox1.Text = movies; } asyncTask<string> LoadMoviesAsync() {var web = newWebClient(); vardTask = web.DownTaskAsync("http://netflix.com"); varrss = awaitdTask ; var movies = XElement.Parse(rss).<story>.<description>; return movies; } Click rss ui.Post{Κ1(rss)} Κ1: K1(rss) ui.Post(Κ2(movie)) Κ2: K2(movie)

19. Demo Using await and async with Silverlight

20. // network strings = awaitwebClient.DownloadStringTaskAsync("http://a.com"); strings = awaitwebClient.UploadStringTaskAsync(newUri("http://b"), "dat"); awaitWebRequest.Create("http://a.com").GetResponseAsync(); awaitsocket.ConnectAsync("a.com",80); awaitworkflowApplication.RunAsync(); awaitworkflowApplication.PersistAsync(); PingReply r = awaitping.SendTaskAsync("a.com"); // stream strings = awaittextReader.ReadToEndAsync(); awaitstream.WriteAsync(buffer, 0, 1024); awaitstream.CopyToAsync(stream2); // UI awaitpictureBox.LoadTaskAsync("http://a.com/pic.jpg"); awaitsoundPlayer.LoadTaskAsync(); // task/await, assuming “task” of type IEnumerable<Task<T>> T[] results = awaitTaskEx.WhenAll(tasks); Task<T>winner = awaitTaskEx.WhenAny(tasks); Task<T> task = TaskEx.Run(delegate {... return x;}); awaitTaskEx.Delay(100); awaitTaskEx.Yield(); awaitTaskScheduler.SwitchTo(); awaitDispatcher.SwitchTo(); Ultimately the contents of TaskEx will be moved into Task. How to use the “Task Async Pattern” [TAP]

21. classForm1 : Form { privatevoidbtnGo_Click(object sender, EventArgs e) { cts = newCancellationTokenSource(); cts.CancelAfter(5000); try { awaitnewWebClient().DownloadStringTaskAsync(newUri("http://a.com"), cts.Token); awaitnewWebClient().DownloadStringTaskAsync(newUri("http://b.com"), cts.Token); } catch (OperationCancelledException) { ... } finally {cts= null;} } CancellationTokenSourcects; privatevoidbtnCancel_Click(object sender, EventArgs e) { if (cts!=null) cts.Cancel(); } } This is the proposed new standard framework pattern for cancellation. Note that cancellation token is able to cancel the current operation in an async sequence; or it can cancel several concurrent async operations; or you can take it as a parameter in your own async methods and pass it on to sub-methods. It is a “composable” way of doing cancellation. How to use TAP cancellation

22. classForm1 : Form { privatevoidbtnGo_Click(object sender, EventArgs e) { varcts = newCancellationTokenSource(); cts.CancelAfter(5000); btnCancel.Click += cts.EventHandler; try { // a slicker, more local way to handle cancellation... awaitnewWebClient().DownloadStringTaskAsync(newUri("http://a.com"), cts.Token); awaitnewWebClient().DownloadStringTaskAsync(newUri("http://b.com"), cts.Token); } catch (OperationCancelledException) { ... } finally{btnCancel.Click -= cts.EventHandler;} } } publicstaticclassExtensions { publicstaticvoidEventHandler(thisCancellationTokenSourcects, object_, EventArgs e) { cts.Cancel(); } } In this version, we keep “cts” local to just the operation it controls. Note that “cts” can’t be re-used: once it has been cancelled, it remains cancelled. That’s why we create a new one each time the user clicks “Go”. A good idea: btnGo.Enabled=false; btnCancel.Enabled=true; How to use TAP cancellation [advanced]

24. This parameter is EventProgress<T>, or any other class that implements IProgress<T>... (it’s up to the consumer how to deal with progress)How to use TAP progress

26. PULL techniques are ones where UI thread choses when it wants to pull the next report – e.g. LatestProgress, QueuedProgress.

27. The classes LatestProgresss and QueuedProgress are in the “ProgressAndCancellation” sample in the CTP.How to use TAP progress [advanced]

28. Task<string[]> GetAllAsync(Uri[] uris, CancellationTokencancel, IProgress<int> progress) { var results = newstring[uris.Length]; for (int i=0; i<uris.Length; i++) { cancel.ThrowIfCancellationRequested(); results[i] = awaitnewWebClient().DownloadStringTaskAsync(uris[i], cancel); if (progress!=null) progress.Report(i); } return results; } Take Cancel/progress parameters: If your API supports both cancellation and progress, add a single overload which takes both. If it supports just one, add a single overload which takes it. Listen for cancellation: either do the pull technique of “cancel.ThrowIfCancellationRequested()” in your inner loop, or the push technique of “cancel.Register(Action)” to be notified of cancellation, or... Pass cancellation down: usually it will be appropriate to pass the cancellation down to nested async functions that you call. Report progress: in your inner loop, as often as makes sense, report progress. The argument to progress.Report(i) may be read from a different thread, so make sure it’s either read-only or threadsafe. How to implement TAP cancellation/progress

29. Task Delay(intms, CancellationTokencancel); Task<T> Run<T>(Func<T> function); Task<IEnumerable<T>> WhenAll<T>(IEnumerable<Task<T>> tasks); Task<Task<T>> WhenAny<T>(IEnumerable<Task<T>> tasks); // WhenAny is like Select. When you await it, you get the task that “won”. // WhenAll over a LINQ query int[] results = awaitTaskEx.WhenAll(fromurlinurlsselectGetIntAsync(url)); // WhenAny to implement a concurrent worker pool Queue<string> todo= ...; var workers = newHashSet<Task<int>>(); for(inti=0; i<10; i++) workers.Add(GetIntAsync(todo.Dequeue()); while (workers.Count>0) { var winner = awaitTaskEx.WhenAny(workers); Console.WriteLine(await winner); workers.Remove(winner); if (todo.Count>0) workers.Add(GetIntAsync(todo.Dequeue()); } Task<T> combinators

30. asyncvoidFireAndForgetAsync() { await t; } asyncTask MerelySignalCompletionAsync() { return; } AsyncTask<int> GiveResultAsync() { return 15; } FireAndForgetAsync(); awaitMerelySignalCompletionAsync(); varr = awaitGiveResultAsync(); Async subs (“void-returning asyncs”): used for “fire-and-forget” scenarios. Control will return to the caller after the first Await. But once “t” has finished, the continuation will be posted to the current synchronization context. Any exceptions will be thrown on that context. Task-returning asyncs: Used if you merely want to know when the task has finished. Exceptions get squirrelled away inside the resultant Task. Task(Of T)-returning asyncs: Used if you want to know the result as well. Three kinds of asyncmethod

31.  // Task Asynchronous Pattern [TAP], with Cancellation and Progress Task<TR> GetStringAsync(Params..., [CancellationTokenCancel], [IProgress<TP>Progress])  // Asynchronous Programming Model [APM]IAsyncResultBeginGetString(Params..., AsyncCallbackCallback, object state);TR EndGetString(IAsyncResult);  // Event-based Asynchronous Pattern [EAP]classC { publicvoidGetStringAsync(Params...); publiceventGetStringCompletedEventHandlerGetStringCompleted; publicvoidCancelAsync(); } classGetStringCompletedEventArgs { publicTR Result { get; } publicException Error { get; } } Comparing TAP to its predecessors

32. Demo Progress and Cancellation

33. Demo Async on Windows Phone 7 (if there’s time)

34. Q & A triplez@justinlee.sg