Going from Tasks back to IAsyncResult(the Asynchronous Programming Model pattern)

There are lot’s of posts out there talking about how to go from the traditional APM approach(using the typical BeginXXX and EndXXX syntax with IAsyncResult) to the Task based approach. Probably the easiest way is by using the Task.Factory.FromAsync method.

But what if you want to do it the other way around and want to go back from a task to the APM way of working?

In my specific case I wanted to wrap the async version of ExecuteNonQuery that returns a Task<int>:

Task<int> ExecuteNonQueryAsync();

It had to be mapped to an APM implementation with the following signatures:

IAsyncResult BeginExecuteNonQuery(DbCommand command, AsyncCallback callback, object state);
int EndExecuteNonQuery(IAsyncResult asyncResult);

I started by implementing it myself but there a lot of edge cases, so I was happy to find the following extension method :

	public static class ToAPMExtension
	{
	static Task<TResult> ToApm<TResult>(this Task<TResult> task, AsyncCallback callback, object state)
	{
	if (task.AsyncState == state)
	{
	if (callback != null)
	{
	task.ContinueWith(delegate { callback(task); },
	CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);
	}
	return task;
	}
	var tcs = new TaskCompletionSource<TResult>(state);
	task.ContinueWith(delegate
	{
	if (task.IsFaulted) tcs.TrySetException(task.Exception.InnerExceptions);
	else if (task.IsCanceled) tcs.TrySetCanceled();
	else tcs.TrySetResult(task.Result);
	if (callback != null) callback(tcs.Task);
	}, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);
	return tcs.Task;
	}
	}

view raw ToAPMExtension.cs hosted with ❤ by GitHub

The implementation of my BeginExecuteNonQuery method became:

	public IAsyncResult BeginExecuteNonQuery(DbCommand command,AsyncCallback callback, object state)
	{
	command.ExecuteNonQueryAsync.ToApm(callback, state);
	}

view raw BeginExecuteNonQuery.cs hosted with ❤ by GitHub

And the implementation of my EndExecuteNonQuery method became:

	public int EndExecuteNonQuery(IAsyncResult asyncResult)
	{
	try
	{
	return ((Task<int>)asyncResult).Result;
	}
	catch(AggregateException ae)
	{
	throw ae.InnerException;
	}
	}

view raw EndExecuteNonQuery.cs hosted with ❤ by GitHub

A similar solution could be found on Stephen Cleary’s blog who created a useful Helper library for async task-based programming called Nito AsyncEx.