await Task.WhenAll() vs Task.WhenAll().Wait()

Question

I have a method that produces an array of tasks (See my previous post about threading) and at the end of this method I have the following options:

await Task.WhenAll(tasks); // done in a method marked with async
Task.WhenAll(tasks).Wait(); // done in any type of method
Task.WaitAll(tasks);

Basically I am wanting to know what the difference between the two whenalls are as the first one doesn't seem to wait until tasks are completed where as the second one does, but I'm not wanting to use the second one if it's not asynchronus.

I have included the third option as I understand that this will lock the current thread until all the tasks have completed processing (seemingly synchronously instead of asynchronus) - please correct me if I am wrong about this one

Example function with await:

public async void RunSearchAsync()
{
    _tasks = new List<Task>();
    Task<List<SearchResult>> products = SearchProductsAsync(CoreCache.AllProducts);
    Task<List<SearchResult>> brochures = SearchProductsAsync(CoreCache.AllBrochures);

    _tasks.Add(products);
    _tasks.Add(brochures);

    await Task.WhenAll(_tasks.ToArray());
    //code here hit before all _tasks completed but if I take off the async and change the above line to:

    // Task.WhenAll(_tasks.ToArray()).Wait();
    // code here hit after _tasks are completed
 }

Answer 1

await will return to the caller, and resume method execution when the awaited task completes.

WhenAll will create a task When All all the tasks are complete.

WaitAll will block the creation thread (main thread) until all the tasks are complete.

Answer 2

Talking about await Task.WhenAll(tasks) vs Task.WhenAll(tasks).Wait(). If execution is in an async context, always try to avoid .Wait and .Result because those break async paradigm.

Those two blocks the thread, nothing other operation can take it. Maybe it is not a big problem in small apps but if you are working with high demand services that is bad. It could lead to thread starvation.

In the other hand await waits for the task to be completed in background, but this does not block the thread allowing to Framework/CPU to take it for any other task.