.NET Async task taking too long to create

Question

Is there a reason for an async Task<> foo() to take time being created? (Just created, awaiting it takes even another chunk of time). When profiling my web service performance I noticed that the mere creation of the task takes a considerable amount of time (in the order of the hundreds of milliseconds).

//DB intensive async tasks, just creating them all takes 600ms-1800ms
Task<Egg> eggTask = FryEggs(2);
Task<Bacon> baconTask = FryBacon(3);
Task<Toast> toastTask = ToastBread(2);
//actually awaiting them takes some hundreds of milliseconds more...
await Task.WhenAll(eggTask, baconTask, toastTask);

The functions in question don't do heavy synchronous work before the first await inside them, so I can't find a compelling reason for them to work this way. Something in this fashion:

async Task<Object> FryEggs(){
    VeryLightweightSynchronousWork();
    await BottleneckingIOWork();
}

I have tried using Task.Factory.StartNew and it does return immediately:

async Task<Object> FryEggs(){
    var res = await Task.Factory.StartNew(async => {
        VeryLightweightSynchronousWork();
        return await BottleneckingIOWork();
    }
    return await res;
}

I don't understand this behaviour.

I actually don't care too much about my specific case, I want to understand why, on a reference-based point of view, should this happen. My current understanding is that a Task starts as soon as it is called, but it should do so asynchronously. So, why would the main thread wait so much for an async task to be created?

Thank you in advance!

Answer 1

just creating them all takes 600ms-1800ms

Most likely, your DB-intensive work is doing some of that work synchronously; perhaps opening the connection, perhaps issuing the command - we can't possibly know. If you show us exactly what FryEggs does, and tell us which ADO.NET provider you're using, we might be able to advise further. Note that some of the ADO.NET providers use async-over-sync for their *Async implementation, which means they're really just synchronous. So the exact ADO.NET provider and version is important to know.

Answer 2

When an async method returns a Task, it is for the continuation of the method. The beginning of the method is still executed immediately.

async Task FryEggs(int count)
{
    //Anything here will cause FryEggs to block the caller until it is completed

    await DoSomethingAsync();

    //Anything down here is the "continuation" which will execute after the task is returned
}

If you want the incomplete task to be returned immediately, you can add an await at the very beginning, e.g. using Task.Yield:

async Task FryEggs(int count)
{
    await Task.Yield();

    //Now this is part of the continuation too. It won't run until after the Task is returned.

    await DoSomethingAsync();
}

I am not sure this is necessarily the best idea for your scenario, but it is an option.

If FryEggs contains CPU-bound work, and you were hoping to improve things through parallelism, you will probably need to run it on a separate thread:

async Task FryEggs(int count)
{
    await Task.Run( () =>
    {
        //Do something super-expensive and synchronous
    });
    await DoSomethingAsync();
}

This way there is an await at the very beginning so control gets yielded back right away. The expensive stuff is placed on its own thread in the thread pool. The logic can access the same local variables through closures; this is safe as long as you await the Task.Run() call.

async Task FryEggs(int count)
{
    string[] results; //This local variable will be closed over

    await Task.Run( () =>
    {
        //Do something super-expensive and synchronous
        results = GetResults();
    });
    await DoSomethingAsync(results);
}