await Task does not wait

Question

I have a simple taken form MS documentation implementation of generic throttle function.

 public async Task RunTasks(List<Task> actions, int maxThreads)
    {
        var queue = new ConcurrentQueue<Task>(actions);
        var tasks = new List<Task>();
        for (int n = 0; n < maxThreads; n++)
        {
            tasks.Add(Task.Run(async () =>
            {
                while (queue.TryDequeue(out Task action))
                {
                    action.Start();
                    await action;
                    int i = 9; //this should not be reached.
                }
            }));
        }
        await Task.WhenAll(tasks);
    }

To test it I have a unit test:

 [Fact]
    public async Task TaskRunningLogicThrottles1()
    {
        var tasks = new List<Task>();
        const int limit = 2;

        for (int i = 0; i < 2000; i++)
        {
            var task = new Task(async () => {
                await Task.Delay(-1);
            });
            tasks.Add(task);
        }
        await _logic.RunTasks(tasks, limit);
    }

Since there is a Delay(-1) in the tasks this test should never complete. The line "int y = 9;" in the RunTasks function should never be reached. However it does and my whole function fails to do what it is supposed to do - throttle execution. If instead or await Task.Delay() I used synchronous Thread.Sleep ot works as exptected.

Answer 1

The Task class has no constructor that accepts async delegates, so the async delegate you passed to it is async void. This is a common trap. Just because the compiler allows us to add the async keyword to any lambda, doesn't mean that we should. We should only pass async lambdas to methods that expect and understand them, meaning that the type of the parameter should be a Func with a Task return value. For example Func<Task>, or Func<Task<T>>, or Func<TSource, Task<TResult>> etc.

What you could do is to pass the async lambda to a Task<TResult> constructor, in which case the TResult would be resolved as Task. In other words you could create nested Task<Task> instances:

var taskTask = new Task<Task>(async () =>
{
    await Task.Delay(-1);
});

This way you would have a cold outer task, that when started would create the inner task. The work required to create a task is negligible, so the inner task will be created instantly. The inner task would be a promise-style task, like all tasks generated by async methods. A promise-style task is always hot on creation. It cannot be created in a cold state like a delegate-based task. Calling its Start method results to an InvalidOperationException.

Creating cold tasks and nested tasks is an advanced technique that is used rarely in practice. The common technique for starting promise-style tasks on demand is to pass them around as async delegates (Func<Task> instances in various flavors), and invoke each delegate at the right moment.