C# 5.0 has introduced the async / await pattern. Where the keyword async specifies that a method, lambda expression or anonymous method is asynchronous. In fact it says that you can use the await keyword to await something. In case of a Task it is the competition.
This is how await works:
var result = await awaitableObject;
This code is roughly transformed in something like this:
var awaiter = awaitableObject.GetAwaiter();
if( ! awaiter.IsCompleted )
{
SAVE_STATE()
(INotifyCompletion awaiter).OnCompleted( continuation)
return;
}
continuation.Invoke()
...
continuation = () =>
{
RESTORE_STATE()
var result = awaiter.GetResult();
}
In fact everything can be made awaitable, even existing classes without modifying them. An object becomes awaitable when it implements a GetAwaiter() method that returns an awaiter for the class. This can be done with an extension method, so the class itself needs not to be modified. The returned awaiter must implement the following things:
bool IsCompleted { get; }
TResult GetResult(); // TResult can also be void
// and implement ethier the INotifyCompletion or ICriticalNotifyCompletion interface
So, what can we do with it without tasks?
We use it in the Crawler-Lib Framework to make our workflow elements awaitable.
await new Delay(3000); // Work after Delay
instead of providing a handler
new Delay(3000, delay => {
// Work after Delay
});
That avoids the deeply nested delegates – and lambda expressions – in case of long sequences. The user of the framework can implement sequences very nice, readable and debugable. We will also use it for our upcoming Storage Operation Processor component, to provide a convenient war to write sequences of storage operations, that are internally queued and optimized.