History of asynchronous in .NET

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

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

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

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

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

Multiple threads
Thread Thread
Thread Thread
Heap memory

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

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

History of asynchronous in .NET

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

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

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);
}
}
}

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}");

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

class Program
{
{
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);
}
}
}

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

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

{
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}");
}

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?

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

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

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;
}

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;
}

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

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;
}

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();
});
}

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);
}
}

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

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

What’s new?
• Lambda expressions

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

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

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

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

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

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

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

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

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

{
Task t1 = Task.Run(Speak);
Task t2 = Task.Factory.StartNew(Speak);
t1.Wait();
t2.Wait();
}
private static void Speak()
{
Console.WriteLine("Hello world");
}

{
var message = "Hello World";
Task t1 = Task.Run(() => SpeakWithParam(message));
Task t2 = Task.Factory.StartNew(() => SpeakWithParam(message));
t1.Wait();
t2.Wait();
}
private static void SpeakWithParam(string textToSpeak)
{
Console.WriteLine(textToSpeak);
}

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

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

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

{
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();
}
}

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

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

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

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);

[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;

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;
}
}

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;

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

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

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

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

History of asynchronous in .NET

More Related Content

What's hot (20)

Similar to History of asynchronous in .NET (20)

Recently uploaded (20)

History of asynchronous in .NET

Editor's Notes