C# Async Await Pattern Without Task. Making the Crawler-Lib Workflow Elements Awaitable

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 need not to be modified. The returned awaiter must implement the following things:

bool IsCompleted { get; }
TResult GetResult(); // TResult can also be void
// and implement either 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.