Running a Task in the background (PCL)

Question

I have a class with an async method:

public static async Task GetData() { ... }

In the app framework I am using I need to start that process and forget about it when the app starts:

protected override void OnStart()
{
    await MyService.GetData();
}

I can't make OnStart async. How do I start it in a background task and forget about it?

Answer 1

I can't make OnStart Async. How do I start it in a background task and forget about it?

Why not? Nothing prevents you from making it async. The async modifier doesn't affect the CLR method signature, i.e., you can override a void method and make it async:

abstract class AppBase
{
    protected abstract void OnStart();
}

class App: AppBase
{
    public static async Task GetData() { await Task.Delay(1); }

    protected override async void OnStart()
    {
        await GetData(); 
    }
}

This way, at least you'll see an exception if GetData throws, unlike what the other answer suggests.

Make sure you understand how async void methods and Task error handling work in general, this material may be helpful.

Some other problems with Task.Run( () => MyService.GetData() ):

• as GetData is already asynchronous, there's very little sense in wrapping it with Task.Run. It's usually only done in a client-side UI app and only if GetData has a long-running synchronous part (before it hits its 1st await). Otherwise, you might as well just call GetData() without Task.Run and without await (which also would be a bad idea: in either case, you'd be doing a fire-and-forget call without observing possible exceptions).

• Task.Run will start GetData on a random pool thread without synchronization content, which may be a problem for either a UI app or an ASP.NET app.

Answer 2

If you want to fire this async operation and forget about it all you need to do is invoke the method without awaiting the returned task:

protected override void OnStart()
{
    MyService.GetDataAsync();
}

However, since you're not observing the task you would never know if it completed successfully.

You should either keep a reference to the task and await it in a later time:

public Task _dataTask;
protected override void OnStart()
{
    _dataTask = MyService.GetDataAsync();
}

public Task AwaitInitializationAsync()
{
    return _dataTask;
}

Or add a continuation handling any exceptions:

protected override void OnStart()
{
    MyService.GetDataAsync().ContinueWith(t => 
    {
        try 
        { 
            t.Wait();
        }
        catch (Exception e)
        {
            // handle exceptions
        }
    });
}

You shouldn't use Task.Run as Noseratio explained, however using async void is much worse since an exception in an async void method (which isn't a UI event handler) would tear down the entire process*.

You can try to make the method async void while making sure there won't be any exceptions thrown inside it with a try-catch block:

protected override async void OnStart()
{
    try
    {
        await GetData(); 
    }
    catch (Exception e)
    {
        // handle e.
    }
}

But I would still recommend against it since even the chance of a complete crash is dangerous.

---

^{*You can get around that by registering an even handler for AppDomain.CurrentDomain.UnhandledException but this should be a last resort, not a best practice}