Asynchronous Programming with C# and WinRT

1. Asynchronous Programming with C# and WinRT Sync vs. Async programming, Tasks, C# 5 async and await, WinRT async operations George Georgiev Telerik Corporation www.telerik.com Technical Trainer itgeorge.net

2. Table of Contents • Synchronous Programming Problems • CPU-demanding tasks, Resource access • Asynchronous Programming • Benefits & Difficulties • Asynchronous Programming in C# • Threads, Tasks, Callback problems • Async Programming with C# and WinRT • Tasks with async & await • Making Asynchronous methods • Error handling async & await code

3. Synchronous Programming

4. Synchronous Programming • Executing program components sequentially • i.e. "Sequential programming" • Actions happen one after another • Uses a single thread of a single process • Components wait for previous components to finish • Program resources are accessible at all points

5. Synchronous Programming Problems • Problems of Sync Programming • If one component blocks, entire program blocks • UI may become unresponsive • No utilization of multi-core systems • CPU demanding tasks delay execution of all other tasks • Accessing resources blocks entire program • Especially problematic with web resources

6. Synchronous Programming Problems • Resource access problems • Resources may be large • While loading, UI blocks • Program stops responding • Resources may be web-based • Slow connections mean slow loading • Server may hang • While accessing, sync programs stop all other operations

7. Resource Access Problems Live Demo

8. Synchronous Programming Problems • CPU-demanding tasks problems • CPU-demanding problems will freeze the program • Program stops responding • Some CPU-demanding tasks are many smaller, independent tasks • Sync programming must sequentially go through them

9. CPU-demanding Tasks Problems Live Demo

10. Asynchronous Programming

11. Asynchronous Programming • Program components can execute in parallel • Some actions run alongside other actions • Each action happens in a separate thread • Independent components don't wait for each other • Program resources shared between threads • If one thread uses a resources, others shouldn't use it

12. Asynchronous Programming Benefits • Benefits of Async Programming • If component blocks, other components still run • Until they need a resource from blocked component • UI runs separately • Always responsive • Utilization of multi-core systems • Each core executes one or several threads • CPU demanding tasks on "background" threads • Resource access runs on "background" threads

13. Asynchronous Programming Difficulties • Hard to imagine which code run at some time • Hard to notify a "component" has executed • So far, callbacks were the way • Have to ensure callback runs in appropriate context (e.g. same thread it started in) • Have to protect resources • One thread uses a resources, others wait for it • Hard to synchronize resource access • Deadlocks and race conditions can occur

14. Asynchronous Programming in C#

15. Async Programming in C# • Thread – smallest, independent piece of a program, executable by the OS • "Subprocess" • Usually contained inside a process • C# is a multi-threaded language by design • Process/program can manage multiple threads • Threads execute in parallel (handled by OS & CPU) • Thread control mechanisms are available in C#

16. Async Programming in C# • Threads and ThreadPool • Direct control over thread execution • Callbacks for Thread events • Tasks – abstraction over Threads • Represent work which will be completed • Wrap delegates/lambdas into objects with Result • Task<int> represents an integer to be calculated • Handle threading "under the hood" • Callbacks for thread events

17. Async Programming with C# • Problems with callbacks • Code becomes hard to track • Exceptions are not propagated properly • Thread context is not saved • i.e. a callback defined in one thread is not guaranteed to work on same thread

18. Async Programming with C# • Thread context problem example: • UI thread attaches a callback to a calculation method • Callback should prints results in a ListView • Calculation method completes -> callback is run • But not on UI thread • The callback has no access to the UI thread's resources and we get a "wrong thread" exception

19. Tasks with async & await The C# 5 approach to asynchronous programming

20. Tasks with async & await • Tasks + async & await = modern approach • Tasks can be "awaited" • Methods can be marked as asynchronous • async and await keywords • Make sense when used together • Enable "inline" multithreaded code • Remove callbacks from code ("flatten") • Code looks like normal sync code • Compiler generates appropriate callbacks

21. Tasks with async & await • async keyword – used on a method signature • Marks a method, which can be asynchronous • Doesn't make it asynchronous – you do, through an "await" • Wraps any returned result in a Task • i.e. method return value is Task (or void) • Means "this could wait for a resource or operation" • If it starts waiting, return to the calling method • When the wait is over, go back to called method

22. Tasks with async & await • await keyword • Used in a method which has async keyword • Saves the context in a state machine • Marks waiting for a resource • Resource should be a Task<T> • Returns T result from Task<T>, when it completes • Means await the completion of a task • While awaiting -> let the rest of the program run • Awaiting over -> continue executing the next statements in the method

23. Tasks with async & await • Using built-in Async methods • WinRT APIs are mainly asynchronous • Any operation which could run for >50ms • Is asynchronous in WinRT • Should be asynchronous in your code • Return some type of IAsyncOperation • Can be awaited just like a Task • Behaves almost the same as a task • Limited control, but convertible to Task

24. Using built-in AsyncMethods Live Demo

25. Making Asynchronous Methods Offloading heavy computations to other threads

26. Making Asynchronous Methods • Any synchronous method can be used asynchronously • Tasks basically call a method • In most cases Task.Run() will be enough • Returns a Task which can be awaited • Under the hood: • Get a free thread • Execute the method in that thread Task<List<int>> primesTask = Task.Run(()=>CalcPrimes(0, 1000)); List<int> primes = await primesTask;

27. Making Asynchronous Methods • "Patterns" to make your code asynchronous • Make a method which returns a Task, which is Run • Call the method and "await" the task result • Make an async method with a return type of Task (or void) • (Optionally) start awaiting a result or action • Return the result as a value (if you have a result) • The compiler will wrap it in a Task • Call the method and await the task result

28. Creating Your Own Async Methods Live Demo

29. Error Handling in async & await Code Try-catch statements with asynchronous code

30. Error Handling async& await • With async & await error-handling is straightforward • Wrap error-prone code in try statement • Catch exceptions • No callbacks in code, so no problem to write try-catch like in normal sync code • Under the hood: • Try-catch is associated with the state machines of the "await"s in it

31. Summary • Store apps should be heavily asynchronous • Tasks with async & await • Modern approach to asynchronous programming • Make code easier to read, take care of thread context and other callback problems • In-depth reading on async & await in WinRT • Asynchronous programming will never be easy • Be wary of deadlocks, race conditions and the like

32. Asynchronous Programming with C# and WinRT http://academy.telerik.com

33. Exercises • Write an app, which calculates primes in a range. • Then gets all of the primes and for each prime: • Finds another prime, which begins with the same digit as the first ends in • Concatenates the two primes (first+second) • According to a setting: • Either finds which of the concatenations are also primes and lists them • Or finds which of the concatenations are NOT primes and lists them • The program should provide UI for 4 calculation requests, each with prime range input, list primes/list non-primes setting and display for the listed concatenations • The UI should always be responsive