Presentation - history of async in .NET

1. History of asynchronous in .NET
Tour around evolution of asynchronous computing in .NET

2. Marcin Tyborowski
• .NET Developer at Billennium
• Speaker
• Co-organizer of Programisotk

3. Why should I analyze the history?
• Better understanding of concept
• See why this mechanism took its current form

4. async await

5. Agenda
• Async programming basics
• History of asynchronous in .NET
• A lot of complaints
• Some WTF’s
• What lies beneath

6. Async programming
writing computer programs so that events happen
outside of the main program flow, in the same
overlapping time frame.

7. Asynchronous models

8. Multiple machines

9. Multiple processes

10. Multiple threads
Thread Thread
Thread Thread
Heap memory

11. All of these have their place in complex
systems, and different languages, platforms,
and technologies tend to favor a particular
model

12. Concurrency vs parallelism

13. Concurrency is about dealing with lots of things at
once.
Parallelism is about doing lots of things at once.

16. What’s new?
• Thread
• ThreadPool
System.Threading namespace

17. Thread
• Simple API for dealing with thread
• 1:1 map to OS thread
• Foreground & background
• A lot of control == a lot of work

18. class Program
{
static void Main(string[] args)
{
Thread thread1 = new Thread(ThreadWork.DoWork);
thread1.Start();
}
}
public class ThreadWork
{
public static void DoWork()
{
for (int i = 0; i < 3; i++)
{
Console.WriteLine("Working thread...");
Thread.Sleep(100);
}
}
}

19. Console.WriteLine($"Current AppDomain: {Thread.GetDomain().FriendlyName}");
Console.WriteLine($"Current Context Id: {Thread.CurrentContext.ContextID}");
Console.WriteLine($"Thread name: {Thread.CurrentThread.Name}");
Console.WriteLine($"Is alive?: {Thread.CurrentThread.IsAlive}");
Console.WriteLine($"State: {Thread.CurrentThread.ThreadState}");
Console.WriteLine($"Priority: {Thread.CurrentThread.Priority}");

20. ThreadPool
• Linked list of work items
• Reuse created threads
• Minimalize responsibility of thread
management

21. class Program
{
static void Main(string[] args)
{
ThreadPool.QueueUserWorkItem(ThreadWork.DoWorkInThreadPool);
}
}
public class ThreadWork
{
public static void DoWorkInThreadPool(object stateInfo)
{
for (int i = 0; i < 3; i++)
{
Console.WriteLine("Hello from threadpool...");
Thread.Sleep(100);
}
}
}

22. What’s wrong?
• Thread is expensive to create
• Uncontroller threads creation
can cause consuming memory
• Working with ThreadPool is still
very complex

23. Asynchronous Programming Model APM
• Introduced with .NET 1.1
• Simplifies working with ThreadPool
• Pair of methods and call object

24. static void Main(string[] args)
{
AddictionDelegate add = AddOperation;
IAsyncResult result =
add.BeginInvoke(10, 5, new AsyncCallback(AddOperationComplete), "someData");
int operationResult = add.EndInvoke(result);
}
static int AddOperation(int a, int b)
{
return a + b;
}
static void AddOperationComplete(IAsyncResult ar)
{
Console.WriteLine($"Write {ar.AsyncState}");
Console.WriteLine($"ThreadId: { Thread.CurrentThread.ManagedThreadId}");
}

25. static void Main(string[] args)
{
AddictionDelegate add = AddOperation;
IAsyncResult result =
add.BeginInvoke(10, 5, new AsyncCallback(AddOperationComplete), "someData");
int operationResult = add.EndInvoke(result);
}
static int AddOperation(int a, int b)
{
return a + b;
}
static void AddOperationComplete(IAsyncResult ar)
{
Console.WriteLine($"Write {ar.AsyncState}");
Console.WriteLine($"ThreadId: { Thread.CurrentThread.ManagedThreadId}");
}

26. static void Main(string[] args)
{
AddictionDelegate add = AddOperation;
IAsyncResult result =
add.BeginInvoke(10, 5, new AsyncCallback(AddOperationComplete), "someData");
int operationResult = add.EndInvoke(result);
}
static int AddOperation(int a, int b)
{
return a + b;
}
static void AddOperationComplete(IAsyncResult ar)
{
Console.WriteLine($"Write {ar.AsyncState}");
Console.WriteLine($"ThreadId: { Thread.CurrentThread.ManagedThreadId}");
}

27. What’s wrong?
• APM make async code very
different from sync code
• Need to run End___ method to
clean up allocated resources
• Problems with GUI apps
• .NET Core?

30. What’s new?
• Synchronization Context
• Event-based Asynchronous Pattern EAP

31. Synchronization Context
• Unification dealing with UI thread in WinForms, WPF, Silverlight
• While initialization UI creates instance of SynchronizationContext

32. Deadlock?

33. public void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
var result = SomeAsyncMethod().Result;
resultTB.Text = result;
}
public async Task<string> SomeAsyncMethod()
{
var result = await FetchDataAsync();
return result;
}

34. public void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
var result = SomeAsyncMethod().Result;
resultTB.Text = result;
}
public async Task<string> SomeAsyncMethod()
{
var result = await FetchDataAsync();
return result;
}

35. public void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
var result = SomeAsyncMethod().Result;
resultTB.Text = result;
}
public async Task<string> SomeAsyncMethod()
{
var result = await FetchDataAsync().ConfigureAwait(false);
return result;
}

36. Event-based Aysynchronous Pattern
• Each operation has
• method to start async work
• event that fires when operation is completed
• Improve error handling
• Resolve UI interaction problems

37. public event CalculationHandler CalculationCompleted;
private void RunCalculation(object sender, RoutedEventArgs e)
{
CalculationCompleted += OnCalculationCompleted;
CalculateSomething(10, 20, sender, new CalculatorEventArgs());
}
private void CalculateSomething(int a, int b, object sender, CalculatorEventArgs
e)
{
e.Result = a + b;
CalculationCompleted.Invoke(sender, e);
}
private void OnCalculationCompleted(object sender, CalculatorEventArgs e)
{
ResultLabel.Text = e.Result.ToString();
CalculationCompleted -= OnCalculationCompleted;
}

38. public event CalculationHandler CalculationCompleted;
private void RunCalculation(object sender, RoutedEventArgs e)
{
CalculationCompleted += OnCalculationCompleted;
CalculateSomething(10, 20, sender, new CalculatorEventArgs());
}
private void CalculateSomething(int a, int b, object sender, CalculatorEventArgs
e)
{
e.Result = a + b;
CalculationCompleted.Invoke(sender, e);
}
private void OnCalculationCompleted(object sender, CalculatorEventArgs e)
{
ResultLabel.Text = e.Result.ToString();
CalculationCompleted -= OnCalculationCompleted;
}

39. public event CalculationHandler CalculationCompleted;
private void RunCalculation(object sender, RoutedEventArgs e)
{
CalculationCompleted += OnCalculationCompleted;
CalculateSomething(10, 20, sender, new CalculatorEventArgs());
}
private void CalculateSomething(int a, int b, object sender, CalculatorEventArgs
e)
{
e.Result = a + b;
CalculationCompleted.Invoke(sender, e);
}
private void OnCalculationCompleted(object sender, CalculatorEventArgs e)
{
ResultLabel.Text = e.Result.ToString();
CalculationCompleted -= OnCalculationCompleted;
}

40. private void RunCalculation(object sender, RoutedEventArgs e)
{
CalculationCompleted += OnCalculationCompleted;
Thread t = new Thread(() => CalculateSomething(10, 20, sender, new
CalculatorEventArgs()));
t.Start();
}
private void OnCalculationCompleted(object sender, CalculatorEventArgs e)
{
Dispatcher.Invoke(() =>
{
ResultLabel.Text = e.Result.ToString();
});
CalculationCompleted -= OnCalculationCompleted;
}

41. private void RunCalculation(object sender, RoutedEventArgs e)
{
CalculationCompleted += OnCalculationCompleted;
Thread t = new Thread(() => CalculateSomething(10, 20, sender, new
CalculatorEventArgs()));
t.Start();
}
private void OnCalculationCompleted(object sender, CalculatorEventArgs e)
{
Dispatcher.Invoke(() =>
{
ResultLabel.Text = e.Result.ToString();
});
CalculationCompleted -= OnCalculationCompleted;
}

42. Error handling

43. private void CalculateSomething(int a, int b, object sender,
CalculatorEventArgs e)
{
try
{
e.Result = a + b;
}
catch (Exception ex)
{
e.Error = ex.Message;
}
finally
{
CalculationCompleted.Invoke(sender, e);
}
}

44. private void OnCalculationCompleted(object sender,
CalculatorEventArgs e)
{
if (e.Error == null)
// Update UI
else
// Log error
CalculationCompleted -= OnCalculationCompleted;
}

45. What’s wrong?
• Still async code is very
different from sync code
• A lot of elements to implement
and be aware of

47. What’s new?
• Lambda expressions

48. delegate int FuncForString(string text);
// C# 1.0 delegate type and delegate instance
FuncForString fun1 = new FuncForString(GetStringLength);

49. delegate int FuncForString(string text);
// C# 2.0 method group conversion
FuncForString fun2 = GetStringLength;

50. // C# 2.0 generic delegate and anonymous method
Func<string, int> fun3 = delegate (string text)
{ return text.Length; };

51. // C# 3.0 lamba expression
Func<string, int> fun4 = (string text) =>
{ return text.Length; };

52. // C# 3.0 no need unnecessary parentheses
Func<string, int> fun7 = text => text.Length;

54. What’s new?
• ThreadPool queue remodelling
• Work stealing queues
• Task Parallel Libarary TPL

55. ThreadPool queue remodelling

56. Work stealing queues

57. Task Parallel Library
• Set of software APIs in the System.Threading.Tasks
• Task represents an asynchronous unit of work
• Easier to use for developers

58. Compute-based task
• Abstraction for OS thread
• Two possibilities
• Create new thread
• Schedule work on reusable ThreadPool
• Task.Run
• TaskFactory.StartNew

59. static void Main(string[] args)
{
Task t = new Task(Speak);
t.Start();
Console.WriteLine("Waiting for completion");
t.Wait();
Console.ReadKey();
}
private static void Speak()
{
Console.WriteLine("Hello world");
}

60. static void Main(string[] args)
{
Task t1 = Task.Run(Speak);
Task t2 = Task.Factory.StartNew(Speak);
Console.WriteLine("Waiting for completion");
t1.Wait();
t2.Wait();
}
private static void Speak()
{
Console.WriteLine("Hello world");
}

61. static void Main(string[] args)
{
var message = "Hello World";
Task t1 = Task.Run(() => SpeakWithParam(message));
Task t2 = Task.Factory.StartNew(() => SpeakWithParam(message));
Console.WriteLine("Waiting for completion");
t1.Wait();
t2.Wait();
}
private static void SpeakWithParam(string textToSpeak)
{
Console.WriteLine(textToSpeak);
}

62. for (int i = 0; i < 10; i++)
{
Task.Factory.StartNew(() => Console.WriteLine(i));
}

64. for (int i = 0; i < 10; i++)
{
int captureI = i;
Task.Factory.StartNew(() => Console.WriteLine(captureI));
}

66. I/O-based task
• Ask for external resource and do other things while waiting for
completion

67. static void Main(string[] args)
{
var url = "https://google.com";
Task task1 = Task.Factory.StartNew(() => DownloadWebPage(url));
// synchronous operations
task1.Wait();
Console.ReadKey();
}
private static string DownloadWebPage(string url)
{
WebRequest request = WebRequest.Create(url);
WebResponse response = request.GetResponse();
var reader = new StreamReader(response.GetResponseStream());
{
return reader.ReadToEnd();
}
}

68. static void Main(string[] args)
{
var url = "https://google.com";
Task task1 = Task.Factory.StartNew(() => DownloadWebPage(url));
// synchronous operations
task1.Wait();
Console.ReadKey();
}
private static string DownloadWebPage(string url)
{
WebRequest request = WebRequest.Create(url);
WebResponse response = request.GetResponse();
var reader = new StreamReader(response.GetResponseStream());
{
return reader.ReadToEnd();
}
}

69. Child tasks
• Parent wait for child
completion
Chained tasks
• ContinueWith
Task
Task Task Task
Task Task Task

70. What’s wrong?
• Code is still different
from sync code

72. What’s new?
• Task-based Asynchronous Pattern
• async/await
• Wait()s, Results no longer needed

73. static async Task<int> TestAsync()
{
Task<int> firstTask = GetNumberAsync(1);
Task<int> secondTask = GetNumberAsync(2);
Task<int> thirdTask = GetNumberAsync(4);
// some synchronous operations
var firstResult = await firstTask;
var secondResult = await secondTask;
var thirdResult = await thirdTask;
return firstResult + secondResult + thirdResult;
}
public static async Task<int> GetNumberAsync(int number)
=> await Task.Run(() => number);

74. static async Task<int> TestAsync()
{
Task<int> firstTask = GetNumberAsync(1);
Task<int> secondTask = GetNumberAsync(2);
Task<int> thirdTask = GetNumberAsync(4);
// some synchronous operations
var firstResult = await firstTask;
var secondResult = await secondTask;
var thirdResult = await thirdTask;
return firstResult + secondResult + thirdResult;
}
public static async Task<int> GetNumberAsync(int number)
=> await Task.Run(() => number);

76. [CompilerGenerated]
[StructLayout(LayoutKind.Auto)]
private struct <TestAsync>d__1 : IAsyncStateMachine
{
public int <>1__state;
public AsyncTaskMethodBuilder<int> <>t__builder;
private int <firstResult>5__2;
private int <secondResult>5__3;
private TaskAwaiter<int> <>u__1;
void IAsyncStateMachine.MoveNext()
{
int num = this.<>1__state;
int result2;

77. try
{
TaskAwaiter<int> awaiter;
switch (num)
{
case 1:
awaiter = this.<>u__1;
this.<>u__1 = default(TaskAwaiter<int>);
this.<>1__state = -1;
goto IL_E1;
case 2:
awaiter = this.<>u__1;
this.<>u__1 = default(TaskAwaiter<int>);
this.<>1__state = -1;
goto IL_14F;
default:
// some code
break;
}
}

78. IL_E1:
result = awaiter.GetResult();
this.<secondResult>5__3 = result;
Console.WriteLine(this.<secondResult>5__3);
awaiter = Program.GetNumberAsync(4).GetAwaiter();
if (!awaiter.IsCompleted)
{
this.<>1__state = 2;
this.<>u__1 = awaiter;
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<int>,
Program.<TestAsync>d__1>(ref awaiter, ref this);
return;
}
IL_14F:
int thirdResult = awaiter.GetResult();
Console.WriteLine("I'm done");
result2 = this.<firstResult>5__2 + this.<secondResult>5__3 +
thirdResult;

79. IL_E1:
result = awaiter.GetResult();
this.<secondResult>5__3 = result;
Console.WriteLine(this.<secondResult>5__3);
awaiter = Program.GetNumberAsync(4).GetAwaiter();
if (!awaiter.IsCompleted)
{
this.<>1__state = 2;
this.<>u__1 = awaiter;
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<int>,
Program.<TestAsync>d__1>(ref awaiter, ref this);
return;
}
IL_14F:
int thirdResult = awaiter.GetResult();
Console.WriteLine("I'm done");
result2 = this.<firstResult>5__2 + this.<secondResult>5__3 +
thirdResult;

80. Summary
• What lies underneath
• Better understanding of concepts
• 95% cases don’t apply
• What about these 5%

81. Summary
• What lies underneath
• Better understanding of concepts
• 95% cases don’t apply
• What about these 5%
• Avoid Wait() and
GetAwaiter().GetResult()

83. Links
https://blog.stephencleary.com/2012/07/dont-block-on-async-code.html
https://foreverframe.net/what-lies-beneath-asyncawait-in-c/
https://github.com/tbr09/Multithreading
https://www.youtube.com/watch?v=ZvglMATXP6o
https://codingcanvas.com/history-of-asynchronous-programming-
models-in-net-framework/
https://docs.microsoft.com/en-us/dotnet/standard/asynchronous-
programming-patterns/task-based-asynchronous-pattern-tap

84. Thanks for your attention 
@mtyborowski09 @tbr09mtyborowski09@gmail.com