Asynchronous Application Patterns in C# - MonkeySpace

Asynchronous Application
Patterns in C#
Frank A. Krueger
@praeclarum

Async
How C# Makes Every Other Language Look Stupid
Frank A. Krueger
@praeclarum

Why Async?
Why Await?
Tour of System.Threading.Tasks
with Real-world Uses of Await
Fak-world Uses of Await

Apps are Async
• Interacting with the user
• Performing computations
• Downloading resources from the web
• Uploading actions and messages to services
• Reading and writing local storage
• Watching for motion changes, camera or
microphone events, network connectivity,
etc.

http://xamarin.com/evolve/2013

And So Async...
• .NET Events
• .NET 1.0 Async (IAsyncResult)

And So Async...
• .NET Events
• Closures! Continuation Passing Style FTW!

And So Async...
• .NET Events
• IObservable<T>

And So Async...
• .NET Events
• IObservable<T>
ARVIS

And So Async...
• .NET Events
• IObservable<T>
Asynchronous Retrieval of
Values from Inﬁnite Streams

And So Async...
• .NET Events
• IObservable<T>
• iOS Delegates

And So Async...
• .NET Events
• IObservable<T>
• iOS Delegates
• iOS Callbacks (Obj-C bocks)

And So Async...
• .NET Events
• IObservable<T>
• iOS Delegates
• iOS Callbacks (Obj-C bocks)
• Android Listeners, Event Interfaces

hugMeanPeopleButton.TouchUpInside += delegate {
// Network IO
var tweets = twitterClient.GetMentions ();
// Computation
var q = from t tweets
where t.IsMean
select t;
// Lots of Network IO
foreach (var enemy in q) {
twitterClient.Reply (enemy, “Here’s a hug”);
}
// UI
statusLabel.Text =
string.Join (“, “, q.Select (x => x.Name)) +
“ have been hugged”;
};
©®™ 2013 Krueger Systems, Inc. All Rights Reserved.

// Network IO
// Computation
where t.IsMean
select t;
twitterClient.Reply (enemy, “Here’s a hug”);
}
// UI
statusLabel.Text =
};
Slow
Slow x N
Slow?

// Network IO
twitterClient.GetMentions (
(tweets, tweetsError) => {
if (tweetsError != null)
Umm (tweetsError);
// Computation
var q = from t in tweets
where t.IsMean
select t;
// This is a loop, believe it or not
tweetsToHug = q.ToList ();
nextTweetToHug = 0;
HugTweet ();
});
}
List<Tweet> tweetsToHug = null;
int nextTweetToHug = 0;
void HugTweet ()
{
if (tweetsToHug == null) return;
if (nextTweetToHug < tweetsToHug.Count) {
var t = tweetsToHug [nextTweetToHug++];
twitterClient.Reply (
t,
“Here’s a hug”,
replyError => {
if (replyError != null)
Umm (replyError);
HugTweet ();
});
return;
}
// UI
statusLabel.Text =
string.Join (“, “,tweetsToHug.Select(x=>x.Name))
+ “ have been hugged”;
tweetsToHug = null;
}
Continuation Passing Style
(CPS)

// Network IO
Umm (tweetsError);
// Computation
where t.IsMean
select t;
nextTweetToHug = 0;
HugTweet ();
});
}
void HugTweet ()
{
t,
replyError => {
Umm (replyError);
HugTweet ();
});
return;
}
// UI
statusLabel.Text =
tweetsToHug = null;
}
2 Functions?

// Network IO
Umm (tweetsError);
// Computation
where t.IsMean
select t;
nextTweetToHug = 0;
HugTweet ();
});
}
void HugTweet ()
{
t,
replyError => {
Umm (replyError);
HugTweet ();
});
return;
}
// UI
statusLabel.Text =
tweetsToHug = null;
}
StateVariables?

// Network IO
Umm (tweetsError);
// Computation
where t.IsMean
select t;
nextTweetToHug = 0;
HugTweet ();
});
}
void HugTweet ()
{
t,
replyError => {
Umm (replyError);
HugTweet ();
});
return;
}
// UI
statusLabel.Text =
tweetsToHug = null;
}
Subtle but Critical
Assignments?

// Network IO
Umm (tweetsError);
// Computation
where t.IsMean
select t;
nextTweetToHug = 0;
HugTweet ();
});
}
void HugTweet ()
{
t,
replyError => {
Umm (replyError);
HugTweet ();
});
return;
}
// UI
statusLabel.Text =
tweetsToHug = null;
}
Recursion?

// Network IO
Umm (tweetsError);
// Computation
where t.IsMean
select t;
nextTweetToHug = 0;
HugTweet ();
});
}
void HugTweet ()
{
t,
replyError => {
Umm (replyError);
HugTweet ();
});
return;
}
// UI
statusLabel.Text =
tweetsToHug = null;
}
Tail End of Process in a
Strange Function?

// Network IO
Umm (tweetsError);
// Computation
where t.IsMean
select t;
nextTweetToHug = 0;
HugTweet ();
});
}
void HugTweet ()
{
t,
replyError => {
Umm (replyError);
HugTweet ();
});
return;
}
// UI
statusLabel.Text =
tweetsToHug = null;
}
Umm...

Our Languages
Were Not Designed for
Asynchronous Procedures

http://channel9.msdn.com/Events/Build/BUILD2011/TOOL-816T

// Network IO
// Computation
where t.IsMean
select t;
twitterClient.Reply (t, “Here’s a hug”);
}
// UI
statusLabel.Text =
};

hugMeanPeopleButton.TouchUpInside += async delegate {
// Network IO
var tweets = await twitterClient.GetMentionsAsync ();
// Computation
where t.IsMean
select t;
await twitterClient.ReplyAsync (t, “Here’s a hug”);
}
// UI
statusLabel.Text =
};

hugMeanPeopleButton.TouchUpInside += async delegate {
// Network IO
var tweets = await twitterClient.GetMentionsAsync ();
// Computation, in the Background, dood
var q = await Task.Run (() =>
from t tweets
where t.IsMean
select t);
await twitterClient.ReplyAsync (t, “Here’s a hug”);
}
// UI
statusLabel.Text =
};

C#
is Designed for
Asynchronous Procedures

Task
TaskCompletionSource
TaskScheduler
CancellationToken

System.Threading.Task
Parallel Process
await task; // Async
task.Wait (); // Synchronous

System.Threading.Task
Fallible Parallel Process
try {
await task; // Async
}
catch (Exception) {
}

System.Threading.Task<T>
Parallel Process
That Returns aValue
var value = await task; // Async
var value = task.Result;

var tweets = await client.GetTweetsAsync ();
await client.PostAsync (“Hello, World!”);
Call an Async Method

await client.PostAsync (“Hello, World!”);
Call an Async Method
Network? CPU? UI?

var value = await Task.Run (() => {
return 42;
});
await Task.Run (() => {
LaunchMissiles ();
});
Start a Background Task
Using a Function

mesh = sphere.Tesselate (opts);

mesh = await Task.Run (() =>
sphere.Tesselate (opts));

async Task<int> GetPopularityAsync ()
{
var followers = await
twitter.GetFollowersAsync ();
return followers.Sum (
x => x.FollowerCount);
}
Methods That Use await
Return Tasks

var value = await Task.Factory.FromAsync (
foo.BeginDoingSomething,
foo.EndDoingSomething,
null);
From .NET 1.0 Async

await Task.Factory.ContinueWhenAll (
downloadTasks,
ts => {});
Combinators
await Task.Factory.ContinueWhenAny (
actionStartGestures,
t => {});

await Task.Factory.ContinueWhenAll (
downloadTasks,
ts => {});
Combinators
await Task.Factory.ContinueWhenAny (
actionStartGestures,
t => {});
Take Multiple Tasks and turn them
into One Task

async Task UpdatePodcasts ()
{
ShowUpdatingUI ();
foreach (var feed in feeds) {
await feed.Update ();
}
ShowUpdatingCompletedUI ();
}
Concurrency?

{
ShowUpdatingUI ();
foreach (var feed in feeds) {
await feed.Update ();
}
}
Concurrency?
Sequential

{
ShowUpdatingUI ();
Task.Factory.ContinueWhenAll (
feeds.Select (x => x.Update ()),
null);
}
Concurrency!
Parallel

TaskCompletionSource<T>
Create tasks
whose execution and
termination you control

Great way to interact with
ancient, old, fuddy duddy,
outdated async models

tcs.Task
tcs.SetResult ()
tcs.SetException ()
tcs.SetCanceled ()

Task<int> GetAnswerAsync ()
{
var tcs = new TaskCompletionSource<int> ();
ThreadPool.QueueUserWorkItem (() => {
BuildAComputer ();
LetItRun ();
tcs.SetResult (42); // Terminate
});
return tcs.Task;
}

Awaiting Callbacks
Task<int> GetAnswerAsync ()
{
GetAnswerCPS (
“input”,
(result, error) => {
if (error != null)
tcs.SetException (error);
else tcs.SetResult (result);
});
return tcs.Task;
}

Awaiting Events
async Task EnterCode ()
{
// Must Tap buttons in the order 4, 2, 3, 3
await button4.Tapped ();
// They get access
RevealSecretUI ();
}

Awaiting Events
static Task<EventArgs> Tapped (this UIButton btn)
{
EventHandler handler;
handler = (s, e) => {
btn.TouchUpInside -= handler;
tcs.SetResult (e);
};
btn.TouchUpInside += handler;
return tcs.Task;
}

Awaiting Generic Events
await button4.Event (“TouchUpInside”);

// Wait for the user to change the name of the
// model to “Frank”
var propEvent = await model.Event (
“PropertyChanged”,
x => x.Name == “Name” && model.Name == “Frank”);

public static Task<EventArgs> Event (
this object eventSource,
string eventName,
Predicate<EventArgs> predicate = null)
{
var tcs = new TaskCompletionSource<EventArgs>();
var type = eventSource.GetType ();
var ev = type.GetEvent (eventName);
EventHandler handler;
handler = delegate (object sender, EventArgs e) {
if (predicate == null || predicate (e)) {
ev.RemoveEventHandler (eventSource, handler);
tcs.SetResult (e);
}
};
ev.AddEventHandler (eventSource, handler);
return tcs.Task;
}

button.TouchUpInside += async delegate {
var project = await ChooseProject ();
project.DoSomethingMindBlowing ();
} 
AwaitingView Controllers

Task<Project> ChooseProject () 
{ 
var tcs = new TaskCompletionSource<Project> (); 
 
var vc = new ChooseProjectViewController (projs); 
vc.Completed += (s, e) => { 
DismissViewController (true, null); 
tcs.SetResult (vc.Project); 
}; 
 
PresentViewController (vc, true, null); 
 
return tcs.Task; 
} 
AwaitingView Controllers

if (await Ask ("Archive", "Cancel") == 0) {
await Archive ();
} 
Awaiting Dialogs

Task<int> Ask (params string[] answers) 
{ 
var tcs = new TaskCompletionSource<int> (); 
 
var sheet = new UIActionSheet (); 
foreach (var a in answers)
sheet.AddButton (a); 
sheet.CancelButtonIndex = answers.Length - 1; 
 
sheet.Clicked += (s, e) => { 
tcs.SetResult (e.ButtonIndex); 
}; 
 
sheet.ShowFrom (View.Bounds, View, true); 
 
return tcs.Task; 
} 
Awaiting Dialogs

And more...
Chaining Animations
Multi-gesture Recognition
Autonomous Services
...

TaskScheduler
Think of it as a Thread

TaskScheduler
it’s not though

TaskScheduler
it’s not though
but close enough

countLabel.Text = tweets.Count;

client.GetTweetsAsync ().ContinueWith (
t => {
if (t.IsFaulted)
throw new AggregateException (t.Exception);
},
TaskScheduler.FromCurrentSynchronizationContext ());

var tweets = await client.GetTweetsAsync ().
ConfigureAwait (false);

client.GetTweetsAsync ().ContinueWith (
t => {
if (t.IsFaulted)
throw new AggregateException (t.Exception);
});
var tweets = await client.GetTweetsAsync ().
ConfigureAwait (false);
Does not synchronize with the UI

CancellationToken
if (token.IsCancellationRequested) {
return;
}

CancellationToken
public Task LaunchTheRockets (
CancellationToken token);

CancellationTokenSource
var cts = new CancellationTokenSource ();
control.LaunchTheRockets (cts.Token);

CancellationTokenSource
var cts = new CancellationTokenSource ();
control.LaunchTheRockets (cts.Token);
// OMG, Cancel the rockets!
cts.Cancel ();

Why Async?
Why Await?
Tour of System.Threading.Tasks
with Real-world Uses of Await
Fak-world Uses of Await
Interlude

*
Map
Location
*
*
Thing
Monkey
GoldLiving Thing
Bat
*
Adventure
Player
IConsole
1
1

Adventure
Player
IConsole
1
interface IConsole
{
TextReader In { get; }
TextWriter Out { get; }
}

Adventure
public static void Main (string[] args)
{
var console = new ConsoleConsole ();
var map = Map.GenerateRandom ();
var player = new Player(
map.StartingLocation,
console);
player.Play ().Wait ();
}

Adventurepublic async Task Play ()
{
while (true) {
// Print the status
await console.Out.WriteLineAsync (Location.Description);
await console.Out.WriteLineAsync (Status);
// Read the command from the user
var command = await console.In.ReadLineAsync ();
if (!string.IsNullOrWhiteSpace (command)) {
// Execute it
var result = Execute (command);
// Print the result
await console.Out.WriteLineAsync (result);
}
}
}

Recognizing
Asynchronous Events

async Task EnterCode ()
{
// Must Tap buttons in the order 4, 2, 3, 3
// They get access
RevealSecretUI ();
}
Recognizing
Asynchronous Events

Recognizing
Asynchronous Events
Recognizing
Human Time Events

Async Tutorial
async Task ShowTheUserHowToSearch ()
{
await Tutorial.EnterText
(searchField, minLength: 3);
await Tutorial.Tap
(searchButton);
await Tutorial.Congratulate
("Now you know how to search.");
} 
http://praeclarum.org/post/45277337108

Turn the Web Server
Inside Out
Instead of waiting for random
requests, specify the requests
you want in the order you
want them.

public class StepByStepServer : WebServer
{
protected override async Task RunSession (WebSession session)
{
await session.Get ("/");
await session.Out.WriteLineAsync (
"<html><h1>Home</h1><a href='step1'>Next</a></html>");
await session.Get ("/hello");
"<html><h1>Hello</h1><a href='done'>Finish</a></html>");
await session.Get ("/done");
"<html><h1>Yay!</h1><a href='/'>Start Over</a></html>");
}
}

public class CounterServer : WebServer
{
{
for (var i = 3; i >= 1; i--) {
await session.Get ();
await session.Out.WriteAsync (i.ToString ());
}
while (true) {
await session.Get ();
await session.Out.WriteAsync ("Go MonkeySpace!");
}
}
}

Adventure on the Web
using the same code as
the Console

public class GameServer : WebServer
{
Map map;
public GameServer (Map map)
{
this.map = map;
}
{
var console = new WebConsole (session);
var player = new Player (map.StartingLocation, console);
await player.Play ();
}
}

Resources
Channel 9 - http://channel9.msdn.com
Xamarin EvolveVideos - http://xamarin.com/evolve/2013
Ask Jon Skeet

Asynchronous Application Patterns in C# - MonkeySpace

Asynchronous Application Patterns in C# - MonkeySpace

Recommended

Recommended

More Related Content

Similar to Asynchronous Application Patterns in C# - MonkeySpace

Similar to Asynchronous Application Patterns in C# - MonkeySpace (20)

More from Frank Krueger

More from Frank Krueger (9)

Recently uploaded

Recently uploaded (20)

Asynchronous Application Patterns in C# - MonkeySpace