Question

How could I convert the method:

static void DoWork(Action<bool> onCompleteCallback)
{            
    Task doWork = new Task( ()=>Thread.Sleep(2000) );

    Action<Task> onComplete = (task) => {
        onCompleteCallback(true); // should execute on the main thread
    };

    doWork.ContinueWith(onComplete, TaskScheduler.FromCurrentSynchronizationContext());
    doWork.Start();                        
}

to Async.

If I convert it to Async what will be the difference?

Answer 1

Part of the reason to use async and await is to avoid callbacks. By using the new async support, your method itself can return a Task (or Task<T>), and you can just use await on it, avoiding the need to pass in a callback entirely.

If you wanted to use the new async/await setup, you’d write this as:

static Task DoWork()
{
     return Task.Run( () => /* Your work */ Thread.Sleep(2000) );            
};

The difference would actually be in how you call this. Instead of using a callback, you’d just write:

await DoWork();
// Do your callback work here - it'll automatically be mapped into the right sync context and happen after the above completes

You could, of course, pass the callback in still, and write it as:

static async Task DoWork(Action<bool> onCompleteCallback)
{            
     await Task.Run( ()=>Thread.Sleep(2000) ); // Or use Task.Delay(2000) if you just want a pause...
     onCompleteCallback(true);
};

This just defeats the purpose (somewhat) of using the new support, as one of the main advantages is that you no longer need to pass around callbacks and turn your logic “inside-out”.