异步并等待调用者不是异步但调用方法是异步的地方

Question

Can anyone explain to me what would happen in the following situation:

public int? getValue()
{
    return GetIntValue().Result;
}

public async Task<int?> GetIntValue()
{
    return await getId();
}

public async Task<int?> getId()
{
    return (await Context.Users.FirstOrDefaultAsync())?.AssignedUserId;
}

and if this situation is any different:

public int? getValue()
{
    return getId().Result;
}

Basically, I am wondering if the await here will cause the execution to continue before the result has been returned in either (or both cases), and if they are different, why are they different?

Answer 1

This getId().Result; is a blocking call that possibly would result in a deadlock scenario. The current thread of execution would block until the function that is called to return.

On the other hand using the async/await approach you will not block. The thread that process this call, would stop and would be available for processing another call. Then when your function call would be completed, the result would be processed by another thread of the thread pool.

Now how the above blocking call would affect your application it depends on the type of your application. For instance if we are talking about a Windows Forms application or a WPF application and this code would be executed on the UI thread your form would freeze until this call being completed. On the other hand if this is a ASP.NET application and you have many requests hitting the server this can result in an exhaustion of the ASP.NET threads, whose purpose is to process the requests that server receives. Apparently, this would result in an application that doesn't respond to new requests, until the some of the requests server received get their response.

Regarding the deadlock scenario, please have a look at this question and especially at the first answer. At this you will find a link to an excellent article on this topic Don't Block on Async Code .

Answer 2

它将导致相同的结果，两者都将等待，直到检索到用户为止，因此getValue（）方法将返回value并且不会返回null。