The Evolution of Async-Programming on .NET Platform (TUP, Full)

The Evolution of Async
Programming on .NET Platform
ZhaoJie @ SNDA
Nov, 2010

About Me
• / / Jeffrey Zhao /

•
• Blog: http://blog.zhaojie.me/
• Twitter: @jeffz_cn
• F#, Scala, JavaScript, Python, .NET, mono...
• Java (as the language) hater

Agenda
• Why & How
• .NET 1.0
• .NET 2.0 / C# 2.0
• .NET 3.0 / F#
• .NET 4.0 / Reactive Framework
• Future / C# vNext

Why?

Because the essence of
Cloud, Web, Mobile
is asynchronous computations

How?

By providing powerful language
features / programming model /
libraries

Two Raw Async Models

• Begin/End
• Event-based
• Both are callback-based
• Which is just “asynchronous” means

Begin/End Async Model
delegate AsyncCallback(IAsyncResult);

interface IAsyncResult {
object AsyncState { get; }
WaitHandle AsyncWaitHandle { get; }
bool CompletedSynchronously { get; }
bool IsCompleted { get; }
}

void BeginXxx(arg1, arg2, ..., AsyncCallback, state);

TResult EndXxx(IAsyncResult);

Let’s write a “Transfer”
method in 4 different
ways

Sync
public static void Transfer(string url, Stream streamOut) {
var request = WebRequest.Create(url);
using (var response = request.GetResponse()) {
var streamIn = response.GetResponseStream();

var size = 1024;
var buffer = new byte[size];
while (true) {
var lengthRead = streamIn.Read(buffer, 0, size);
if (lengthRead <= 0) break;
streamOut.Write(buffer, 0, lengthRead);
}
}
}

Async
IAsyncResult BeginTransfer(url, streamOut, ..., callback) {
// keep context and BeginGetResponse
}

void EndGetResponse(...) {
// get streamIn and BeginRead
}

void EndRead(...) {
// data read, completed or BeginWrite
}

void EndWrite(...) {
// data wrote, BeginRead
}

Async
1 IAsyncResult BeginTransfer(url, streamOut, ..., callback) {
}

}

void EndRead(...) {
}

}

Async
}
2
}

void EndRead(...) {
}

}

Async
}
2
}
3
void EndRead(...) {
}

}

Async
}
2
}
3
void EndRead(...) {
}
4

}

Async
}
2
}
3
void EndRead(...) {
}
5 4

}

Async
}
2
}
3
void EndRead(...) {
// data read, completed or BeginWrite 6
}
5 4

}

Robust & Sync
public void Transfer(string url, Stream streamOut) {
try {
using (var response = request.GetResponse()) {

var size = 1024;
var buffer = new byte[size];
while (true) {
var lengthRead = streamIn.Read(buffer, 0, size);
streamIn.Write(buffer, 0, lengthRead);
}
}
} catch {
// ...
}
}

Robust & Async
IAsyncResult BeginTransfer(url, streamOut, ..., callback) {
try { ... } catch { ... }
}

try { ... } catch { ... }
}

void EndRead(...) {
try { ... } catch { ... }
}

try { ... } catch { ... }
}

Event-based Async Model
class XxxCompletedEventArgs : EventArgs {
Exception Error { get; }
TResult Result { get; }
}

class Worker {
event EventHandler<XxxCompletedArgs> XxxCompleted;
void XxxAsync(arg1, arg2, ...);
}

The Evolution of Async-Programming on .NET Platform (TUP, Full)

Code Locality is Broken

• Used to expressing algorithms linearly
• Async requires logical division of algorithms
• No if / using / while / for ...

• Very difﬁcult to
• Combine multiple asynchronous operations
• Deal with exceptions and cancellation

“yield” for Iterators
IEnumerable<int> Numbers() {

yield return 0;

yield return 1;

yield return 2;

}

MoveNext()
yield return 0;

yield return 1;

yield return 2;

}

MoveNext()
yield return 0;

MoveNext()
yield return 1;

yield return 2;

}

MoveNext()
yield return 0;

MoveNext()
yield return 1;

MoveNext()
yield return 2;

}

MoveNext()
yield return 0;

MoveNext()
yield return 1;

MoveNext()
yield return 2;
MoveNext()
}

Async with “yield”
IEnumerator<int> Transfer(AsyncEnumerator ae, string url, Stream streamOut) {
request.BeginGetResponse(ae.End(), null);
yield return 1;

using (var response = request.EndGetResponse(ae.DequeueAsyncResult())) {
byte[] buffer = new byte[1024];
while (true) {
streamIn.BeginRead(buffer, 0, buffer.Length, ae.End(), null);
yield return 1;

int lengthRead = streamIn.EndRead(ae.DequeueAsyncResult());
streamOut.BeginWrite(buffer, 0, lengthRead, ae.End(), null);
yield return 1;

streamOut.EndWrite(ae.DequeueAsyncResult());
}
}
}

yield return 1;

while (true) {
“yield” after yield return 1;
ﬁring async
operations
yield return 1;

streamOut.EndWrite(ae.DequeueAsyncResult());
}
}
}

yield return 1;

while (true) {
“yield” after yield return 1;
ﬁring async
operations
yield return 1;

streamOut.EndWrite(ae.DequeueAsyncResult()); continue when
} async operations
} completed
}

“yield return” for Async

• Coming with new programming patterns
• Keep code locality
• Good parts: support if / using / while / for ...
• But not perfect: cannot use try...catch

• The primitives for Fibers - lightweight
computation units

F#
• Language by Don Syme, MS Research
• Strongly statically typed language
• Functional language with OO ability
• For industry and education
• Open source (Apache 2.0)
• Cross-platform supported by Microsoft

Concurrency Challenges

• Shared State - Immutability
• Code Locality - async { ... }
• I/O Parallelism - async { ... }
• Scaling to Multi-Machine - Agents with
async { ... }

What’s async { ... }
... the principle we go by is, don't expect to see
a particular concurrency model put into C#
because there're many different concurrency
model ... it's more about ﬁnding things are
common to to all kinds of concurrency ...

- Anders Hejlsberg

Async Workﬂow
async {
let! res = <async work>
...
}

Async Workﬂow
React!
async {
...
}

Async Workﬂow
React!
async {
...
}
an HTTP Response
an UI Event
a Timer Callback
a Query Response
a Web Servcie Response
a Disk I/O Completion
an Agent Message

Async in F#
let transferAsync (url: string) (streamOut: Stream) = async {

let request = WebRequest.Create(url)
use! response = request.AsyncGetResponse()
let streamIn = response.GetResponseStream()

let rec transferDataAsync (buffer: byte[]) = async {
let! lengthRead = streamIn.AsyncRead(buffer, 0, buffer.Length)
if lengthRead > 0 then
do! streamOut.AsyncWrite(buffer, 0, lengthRead)
do! transferDataAsync buffer
}

do! transferDataAsync (Array.zeroCreate 1024)
}

Async in F#
let transferAsync (url: string) (streamOut: Stream) = async {

let request = WebRequest.Create(url)
use! response = request.AsyncGetResponse()
AsyncGetResponse
let streamIn = response.GetResponseStream()

let rec transferDataAsync (buffer: byte[]) = async {
let! lengthRead = streamIn.AsyncRead(buffer, 0, buffer.Length)
AsyncRead
if lengthRead > 0 then
do! streamOut.AsyncWrite(buffer, 0, lengthRead)
AsyncWrite
do! transferDataAsync buffer
}
simply generate from
do! transferDataAsync (Array.zeroCreate 1024) Begin/End methods
}

How async { ... } Works
async {
let! img = AsyncRead "http://..."
printfn "loaded!"
do! AsyncWrite img @"c:..."
printfn "saved!" }

How async { ... } Works
async {
let! img = AsyncRead "http://..."
printfn "loaded!"
do! AsyncWrite img @"c:..."
printfn "saved!" }

=
async.Delay(fun ->
async.Bind(AsyncRead "http://...", (fun img ->
printfn "loaded!"
async.Bind(AsyncWrite img @"c:...", (fun () ->
printfn "saved!"
async.Return())))))

F# Async Workﬂow
• Library, not a language feature
• Based on Computation Expressions in F#

• Support all kinds of language constructions
• Error handling: try...catch
• Loop: while / for (like “foreach” in C#)
• Others: if / use (like “using” in C#), etc.

• Easy to
• Combine multiple asynchronous operations
• Deal with exceptions and cancellation

F# Resources
http://fsharp.net

Programming F# Expert F# 2.0 Real World FP

.NET 4.0 / Reactive
Framework

Reactive Framework

Fundamentally change the way you
think about coordinating and
orchestrating asynchronous and
event-based programming

How

By showing that asynchronous and
event-base computations are just
push-based collections

Interactive Reactive
Environment

Program

Enumerable Collections
interface IEnumerable<out T> {
IEnumerator<T> GetEnumerator();
}

interface IEnumerator<out T> {
bool MoveNext();
T Current { get; }
}

Observable Collections
interface IObservable<out T> {
IDisposable Subscribe(IObserver<T> o)
}

interface IObserver<in T> {
void OnCompleted();
void OnNext(T item);
void OnError(Exception ex);
}

IEnumerable & IEnumerator are prototypical
interfaces for interactive collections and
interactive programs.

IObservable & IObserver are prototypical
interfaces for observable collections and
reactive, asynchronous & event-based programs.

LINQ to Observable

If you are writing
LINQ or declarative code
in an interactive program...

LINQ to Observable

If you are writing
LINQ or declarative code
in an interactive program...

You already know how to use it!

Again
... the principle we go by is, don't expect to see
a particular concurrency model put into C#
because there're many different concurrency
model ... it's more about ﬁnding things are
common to to all kinds of concurrency ...

- Anders Hejlsberg

Move by WASD
// filter the KeyPress events when playing
var keyPress = GetKeyPress().Where(_ => isPlaying);

// filter the events to move left
var moveLeft = from ev in keyPress
where ev.EventArgs.KeyChar == 'a'
where ball.Left > 0
select ev;
moveLeft.Subscribe(_ => ball.Left -= 5);

// filter the events to move top
var moveTop = from ev in keyPress
where ev.EventArgs.KeyChar == 'w'
where ball.Top > 0
select ev;
moveTop.Subscribe(_ => ball.Top -= 5);

Mouse Drag and Draw
var mouseMove = GetMouseMove();
var mouseDiff = mouseMove.Zip(mouseMove.Skip(1),
(prev, curr) => new
{
PrevPos = new Point(
prev.EventArgs.X, prev.EventArgs.Y),
CurrPos = new Point(
curr.EventArgs.X, curr.EventArgs.Y)
});

var mouseDrag = from _ in GetMouseDown()
from diff in mouseDiff.TakeUntil(GetMouseUp())
select diff;

mouseDrag.Subscribe(d => DrawLine(d.PrevPos, d.CurrPos));

Everything in Web is
Asynchronous
• User actions
• AJAX requests
• Animations
• ...

Rx in JavaScript
• A full featured port for JavaScript
• Easy-to-use conversions from existing DOM,
XmlHttpRequest, etc
• In a download size of less than 7kb (gzipped)

• Bindings for various libraries / frameworks
• jQuery
• MooTools
• Dojo
• ...

Drag and Draw in JS
var target = $("#paintPad");
var mouseMove = target.toObservable("mousemove");
var mouseDiff = mouseMove.Zip(mouseMove.Skip(1),
function(prev, curr) {
return {
prevPos: { x: prev.clientX, y: prev.clientY },
currPos: { x: curr.clientX, y: curr.clientY }
};
});

var mouseDown = target.toObservable("mousedown");
var mouseUp = target.toObservable("mouseup");
var mouseDrag = mouseDown.SelectMany(function() {
mouseDiff.TakeUntil(mouseUp);
});

mouseDrag.Subscribe(
function(d) { drawLine(d.prevPos, d.currPos); });

Wikipedia Lookup
var textBox = $("#searchInput");
var searcher = textBox
.toObservable("keyup")
.Throttle(500)
.Select(function(_) { return textBox.val(); })
.Select(function(term) { return queryWikipedia(term); })
.Switch();

searcher.Subscribe(
function(data) {
var results = $("#results");
results.empty();
$.each(data, function(_, value) {
results.append($("<li/>").text(value));
});
},
function(error) { $("#error").html(error); });

Time Flies like an Arrow
var container = $("#container");
var mouseMove = container.toObservable("mousemove");

for (var i = 0; i < text.length; i++) {
(function(i) {
var ele = $("<span/>").text(text.charAt(i));
ele.css({position: "absolute"}).appendTo(container);

mouseMove.Delay(i * 100).Subscribe(function (ev) {
ele.css({
left: ev.clientX + i * 20 + 15 + "px",
top: ev.clientY + "px"
});
});

})(i);

Beneﬁts of Rx
• Easy to composite and coordinate async
operations

• Express the algorithm in functional ways
• Helper method: For / While / If / Try / Switch...

• Easy to be unit tested
• ...

Rx & Language Features
• Features in C# that Rx uses
• Extension method
• Lambda expression & closure
• Type inference
• LINQ query expression

• Rx has been implemented in ...
• C# & VB
• JavaScript
• F#

Portability
• Rx can be easily ported to various languages
• Scala
• Ruby
• Python
• modern languages with basic functional features

• Almost impossible to implement Rx in Java
• Cannot extend a type without breaking code
• Missing enough functional features

Rx Resources
• Matthew Podwysocki
• http://codebetter.com/blogs/matthew.podwysocki/

• Reactive Framework on MSDN DevLabs
• http://msdn.microsoft.com/en-us/devlabs/
ee794896.aspx

• Tomáš Petříček
• http://tomasp.net/

Comparison

• F# Async Workﬂow
• Elegant, simple, easy to use
• Can only be used at server-side (WebSharper come to
rescure?)

• Reactive Framework
• Can be used at both server-side and client-side.
• New async model brings learning cost.

Out of Topic

Can we programming like F# in JavaScript?

Jscex & Jscex.Async

• Computation Expressions and Async
Workﬂow implemented in JavaScript

• http://github.com/jeffreyzhao/jscex

Clock

var drawClockAsync = eval(Jscex.compile("$async",
function(interval) {
while (true) {
drawClock(new Date());
$await(Jscex.Async.sleep(interval));
}
}
));

Jscex.Async.start(drawClockAsync(1000));

Animation
var moveAsync = eval(Jscex.compile("$async",
function(e, start, end, duration) {
for (var t = 0; t < duration; t += 50) {
e.style.left = start.x + (end.x - start.x) * t / duration;
e.style.top = start.y + (end.y - start.y) * t / duration;
$await(Jscex.Async.sleep(50));
}

e.style.left = end.x;
e.style.top = end.y;
}
));

var moveSquareAsync = eval(Jscex.compile("$async", function(e) {
$await(moveAsync(e, {x:100, y:100}, {x:400, y:100}, 1000));
}));

Source

async Task<XElement> GetRssAsync(string url) {
var client = new WebClient();
var task = client.DownloadStringTaskAsync(url);
var text = await task;
var xml = XElement.Parse(text);
return xml;
}

Compiled
Task<XElement> GetRssAsync(string url) {
var $builder = AsyncMethodBuilder<XElement>.Create();
var $state = 0;
TaskAwaiter<string> $a1;
Action $resume = delegate {
try {
if ($state == 1) goto L1;
var client = new WebClient();
var task = client.DownloadStringTaskAsync(url);
$state = 1;
$a1 = task.GetAwaiter();
if ($a1.BeginAwait($resume)) return;
L1: var text = $a1.EndAwait();
var xml = XElement.Parse(text);
$builder.SetResult(xml);
}
catch (Exception $ex) { $builder.SetException($ex); }
};
$resume();
return $builder.Task;
}

Conclusion

• Async Programming is difﬁcult
• New programming language / feature /
library / model can help

The Evolution of Async-Programming on .NET Platform (TUP, Full)

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to The Evolution of Async-Programming on .NET Platform (TUP, Full) (20)

More from jeffz (20)

The Evolution of Async-Programming on .NET Platform (TUP, Full)