See intro blogpost here.
When you start working with WinRT, you start seeing classes missing or changed. A lot of methods are now only asynchronous, like making a web request, opening, reading and writing files etc. They all now on the Task framework, and they do this to ensure you application is always responsive. However without this framework, it would be a pain to code against an API that’s inherently asynchronous all the way through. But with it, it makes it really easy to write code against it.
As an example here’s how you normally write async operations in WPF and Silverlight:
var myObject = new MyClass();
myObject.Completed += (sender,e) => {
//Completed event handler
if(e.Error == null) {
statusText.Text = "My Operation has completed: " + e.Result;
}
};
myObject.StartAsync(); //Starts process and fires "Completed" event when done
So we first hook up to the event handler, then call start. When you look at the code, the lines are not executed in the order they are written. The completed delegate executes after the operation completes after Start() has been run (even explaining it makes it sound confusing). Also you cannot throw exceptions from an asynchronous running process, because there will be no way to catch it, so you’ll have to parse an exception object back as part of your result and check it.
This pattern makes it hard to read and understand the code, since it’s not immediately obvious what code runs when. Especially when the code gets more complex and/or your eventhandlers are declared elsewhere. When we then nest events, it gets very convoluted quickly:
var myObject = new MyClass();
myObject.Completed += (sender,e) => {
if(e.Error == null) {
//Perform next operation
var myObject2 = new MyClass();
myObject2.Completed += (sender2,e2) => {
if(e2.Error == null) {
//Completed event handler
statusText.Text = "My Operation has completed: " + e2.Result;
}
};
myObject2.StartAsync();
}
};
myObject.StartAsync();
With the Task framework this becomes very simple and straightforward to write and more importantly read:
var myObject = new MyClass();
try {
string result = await myObject.StartAsync();
var myObject2 = new MyClass();
string result2 = await myObject2.StartAsync();
statusText.Text = "My Operation has completed: " + result2;
}
catch { }
Notice that we don’t bother with checking an error object. We simply use try/catch instead, and the task returns the result up front. If it wasn’t for the little “await” keyword, it looks like this is just good ol’ synchronous programming! This is pure awesomeness!
If you are planning on porting a large application from Silverlight or WPF and it uses a lot of event-based asynchronous programming, you are probably in for some work. Not to say that your application can’t use events, but a lot of the WinRT API’s don’t have eventhandlers any more, so if you insist on keeping it this way, you would have to wrap all the built in tasks into some event-based classes. I would probably rather focus on moving forward and getting this cleaned up. And since the Task framework is already available in .NET 4 and there’s a CTP for Silverlight (and included in upcoming v5!) and WinPhone, you could port your original code to start taking advantage of this, making your code reuse easier and cleaner moving forward.
So how would you go about wrapping an event-based class into a task based method? Well let’s continue using the MyClass example above, and wrap it in a task. Here’s how that would look:
public Task<string> StartAsync()
{
var tcs = new TaskCompletionSource<string>();
var obj = new MyClass();
obj.Completed += (sender,e) => {
if (e.Error != null)
tcs.TrySetException(e.Error);
else
tcs.TrySetResult(e.Result);
};
obj.StartAsync();
return tcs.Task;
}
Basically we return Task of string, instead of just a string. We use the TaskCompletionSource of string to handle error and result messaging back to the task.
So when should you make a method an asynchronous task? The rule of thumb is: If it takes more than 50ms to execute, it should be asynchronous! This helps a lot towards preventing the UI from becoming choppy and/or unresponsive.