The document discusses concurrency and asynchronous programming in .NET. It covers three pillars of concurrency: scalability using Parallel.For, responsiveness using tasks and async/await, and consistency using locks, mutexes, etc. It demonstrates how async/await allows programs to be responsive by freeing threads for other work while waiting for I/O. A key point is that the SynchronizationContext impacts asynchronous code behavior and can cause unintended threading issues if not properly understood.

1. http://www.slideshare.net/martenrange/

2. Mårten Rånge
Ericsson AB
@marten_range

3. Concurrency
Examples for .NET

5. Responsive

6. Performance
Scalable algorithms

7. Three pillars of Concurrency
 Scalability (CPU)
 Parallel.For
 Responsiveness
 Task
 async/await
 Consistency
 lock
 Interlocked.*
 Mutex/Event/Semaphore
 Monitor

8. Responsiveness

10. string ReadSomeText (string fileName)
{
using (var sr = new StreamReader(fileName))
{
var result = sr.ReadToEnd ();
return result;
}
}
// Blocks the thread until IO completes
var text = ReadSomeText ("SomeText.txt");

11. Asyncronous programming allows
programs to be responsive

12. async Task<string> ReadSomeTextAsync(string fileName)
{
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
return result;
}
}

13. async Task<string> ReadSomeTextAsync(string fileName)
{
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
return result;
}
}

14. async Task<string> ReadSomeTextAsync(string fileName)
{
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
return result;
}
}

15. async Task<string> ReadSomeTextAsync(string fileName)
{
using (var sr = new StreamReader(fileName))
{
var first = await sr.ReadLineAsync();
var second = await sr.ReadLineAsync();
var third = await sr.ReadLineAsync();
return first + second + third;
}
}

16. async Task<string> ReadSomeTextAsync(string fileName)
{
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
return result;
}
}
// Is this code correct?
var readTask = ReadSomeTextAsync ("SomeText.txt");
var text = readTask.Result;

17. It depends

18. // Is this code correct (ignore exceptions)?
async Task<string> ReadSomeTextAsync(string fileName)
{
++m_readingFiles;
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
--m_readingFiles;
return result;
}
}

19. It depends

20. // Does both TraceTheadId() trace the same id?
async Task<string> ReadSomeTextAsync(string fileName)
{
TraceThreadId ();
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
TraceThreadId ();
return result;
}
}

21. It depends

22. What’s going on?

23. Your new ”best” friends
 SynchronizationContext
 Console apps
 Continues on ThreadPool thread
 WindowsFormsSynchronizationContext
 Used by WindowsForms apps
 Continues on the ”UI” thread
 DispatcherSynchronizationContext
 Used by WPF and ASP.NET apps
 Continues on the ”same” thread

24. SynchronizationContext

25. async Task<string> ReadSomeTextAsync(string fileName)
{
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
return result;
}
}
// Is this code correct?
var readTask = ReadSomeTextAsync ("SomeText.txt");
var text = readTask.Result;

26. Yes

27. // Is this code correct (ignore exceptions)?
async Task<string> ReadSomeTextAsync(string fileName)
{
++m_readingFiles;
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
--m_readingFiles;
return result;
}
}

28. No

29. // Does both TraceTheadId() trace the same id?
async Task<string> ReadSomeTextAsync(string fileName)
{
TraceThreadId ();
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
TraceThreadId ();
return result;
}
}

30. No

31. DispatcherSynchronizationContext
&
WindowsFormsSynchronizationContext

32. async Task<string> ReadSomeTextAsync(string fileName)
{
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
return result;
}
}
// Is this code correct?
var readTask = ReadSomeTextAsync ("SomeText.txt");
var text = readTask.Result;

33. No

34. // Is this code correct (ignore exceptions)?
async Task<string> ReadSomeTextAsync(string fileName)
{
++m_readingFiles;
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
--m_readingFiles;
return result;
}
}

35. Yes

36. // Does both TraceTheadId() trace the same id?
async Task<string> ReadSomeTextAsync(string fileName)
{
TraceThreadId ();
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync();
TraceThreadId ();
return result;
}
}

37. Yes

38. So…

39. SynchronizationContext
 Is ”invisible”
 Is a thread-global state
 Impacts the behavior of your code significantly
 As an application developer you can make assumptions
 As a library developer you can’t make assumptions

40. ConfigureAwait

41. async Task<string> ReadSomeTextAsync(string fileName)
{
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync()
.ConfigureAwait (false);
return result;
}
}
// Is this code correct?
var readTask = ReadSomeTextAsync ("SomeText.txt");
var text = readTask.Result;

42. Yes

43. // Is this code correct (ignore exceptions)?
async Task<string> ReadSomeTextAsync(string fileName)
{
++m_readingFiles;
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync()
.ConfigureAwait (false);
--m_readingFiles;
return result;
}
}

44. No

45. // Does both TraceTheadId() trace the same id?
async Task<string> ReadSomeTextAsync(string fileName)
{
TraceThreadId ();
using (var sr = new StreamReader(fileName))
{
var result = await sr.ReadToEndAsync()
.ConfigureAwait (false);
TraceThreadId ();
return result;
}
}

46. No

47. async/await tries to be what we want

48. async/await reminds me of…

49. What we need
 Do one thing
 Responsiveness
 Predictable semantics
 Continuation is executed by a thread-pool thread
 Visibility
 Thread-switching should be visible in code

50. F# async
// Focuses on responsiveness
let gameLoop =
async {
// Switching to new thread is explicit
do! Async.SwitchToNewThread ()
while true do
// let! is like await in C#
let! messages = fromVisual.AsyncDequeue 1000
for message in messages do
processMessage message
}

51. C#
 yield
 Special support for enumerators
 LINQ
 Special support for SQL-like syntax
 async/await
 Special support for asynchronous programming

52. F#
 seq { for x in 0..10 -> i }
 Enumerators implemented using Computation Expressions
 query { for c in db.Customers do select c }
 SQL-like syntax implemented using Computation Expressions
 async { let! r=fromVisual.AsyncDequeue 1000 in r }
 Asynchronous programming using Computation Expressions

53. Computation Expressions

54. With async/await always consider the…

55. SynchronizationContext
SynchronizationContext
SynchronizationContext
SynchronizationContext
SynchronizationContext
SynchronizationContext
SynchronizationContext
SynchronizationContext
SynchronizationContext
SynchronizationContext
SynchronizationContext

56. Mårten Rånge
Ericsson AB
@marten_range

57. Links
 Presentation
 http://www.slideshare.net/martenrange/
 Code
 https://github.com/mrange/presentations/
 DIY asynchronous workflows in F#
 http://mrange.wordpress.com/2014/06/12/diy-asynchronous-workflows-
in-f/
 Asynchronous programming with async/await
 http://msdn.microsoft.com/en-us/library/hh191443.aspx