await vs Task Wait - Deadlock

Question

I don t quite understand the difference between Task Wait and await   I have something similar to the following functions in a ASP NET WebAPI service   public class TestController   ApiController       public static async Task lt string gt  Foo                 await Task Delay 1  ConfigureAwait false           return                public async static Task lt string gt  Bar                 return await Foo               public async static Task lt string gt  Ros                 return await Bar                  GET api test     public IEnumerable lt string gt  Get                 Task WaitAll Enumerable Range 0  10  Select x   gt  Ros    ToArray              return new string      value1    value2        This will never execute           Where Get will deadlock   What could cause this  Why doesn t this cause a problem when I use a blocking wait rather than await Task Delay

User · Answer

Some important facts were not given in other answers:

"async await" is more complex at CIL level and thus costs memory and CPU time.

Any task can be canceled if the waiting time is unacceptable.

In the case "async await" we do not have a handler for such a task to cancel it or monitoring it.

Using Task is more flexible then "async await".

Any sync functionality can by wrapped by async.

public async Task<ActionResult> DoAsync(long id) 
{ 
    return await Task.Run(() => { return DoSync(id); } ); 
}

"async await" generate many problems. We do not now is await statement will be reached without runtime and context debugging. If first await not reached everything is blocked. Some times even await seems to be reached still everything is blocked:

https://github.com/dotnet/runtime/issues/36063

I do not see why I'm must live with the code duplication for sync and async method or using hacks.

Conclusion: Create Task manually and control them is much better. Handler to Task give more control. We can monitor Tasks and manage them:

https://github.com/lsmolinski/MonitoredQueueBackgroundWorkItem

Sorry for my english.

User · Answer

Based on what I read from different sources   An await expression does not block the thread on which it is executing  Instead  it causes the compiler to sign up the rest of the async method as a continuation on the awaited task  Control then returns to the caller of the async method  When the task completes  it invokes its continuation  and execution of the async method resumes where it left off   To wait for a single task to complete  you can call its Task Wait method  A call to the Wait method blocks the calling thread until the single class instance has completed execution  The parameterless Wait   method is used to wait unconditionally until a task completes  The task simulates work by calling the Thread Sleep method to sleep for two seconds   This article is also a good read

User · Answer

Wait and await - while similar conceptually - are actually completely different   Wait will synchronously block until the task completes  So the current thread is literally blocked waiting for the task to complete  As a general rule  you should use  async all the way down   that is  don t block on async code  On my blog  I go into the details of how blocking in asynchronous code causes deadlock   await will asynchronously wait until the task completes  This means the current method is  paused   its state is captured  and the method returns an incomplete task to its caller  Later  when the await expression completes  the remainder of the method is scheduled as a continuation   You also mentioned a  cooperative block   by which I assume you mean a task that you re Waiting on may execute on the waiting thread  There are situations where this can happen  but it s an optimization  There are many situations where it can t happen  like if the task is for another scheduler  or if it s already started or if it s a non-code task  such as in your code example  Wait cannot execute the Delay task inline because there s no code for it    You may find my async   await intro helpful

[c#] await vs Task.Wait - Deadlock?

Examples related to c#

Examples related to task-parallel-library

Examples related to deadlock

Examples related to async-await