`await` vs. `Task.Result`: When Should You Use Each and Why Does One Cause Deadlocks?

and : Different use of usage and cause of the deadlock await Task.Result When processing asynchronous code, it is important to understand the difference between

and

to obtain results. Confusion may lead to dead locks, especially when using APIs that implement asynchronous methods. await Task.Result Consider the following test scene:

In this test, we first tried to use

<code class="language-csharp">[Test]
public async void CheckStatusTwiceResultTest()
{
    Assert.IsTrue(CheckStatus().Result); // 此处挂起
    Assert.IsTrue(await CheckStatus());
}</code>

from the asynchronous method

to get the result. However, this method will be hung because we are actually performing the completion of the mission in synchronization and blocking the execution thread. Task.Result CheckStatus To understand why this happens, we need to check the

Method:

CheckStatus

This method uses for asynchronous API calls, which means that execution will continue without waiting for response. When we call this asynchronous method

<code class="language-csharp">private async Task<bool> CheckStatus()
{
    // 进行 REST API 调用
    IRestResponse<dummyservicestatus> response = await restResponse;
    return response.Data.SystemRunning;
}</code>

, it will actually block the execution thread and wait for the results.

await Because the method itself contains asynchronous operations (REST API calls), trying through Task.Result synchronous waiting will cause dead locks. The main execution thread is waiting for the results of the API call, and the API call is waiting for the main thread to continue executing.

The correct method of accessing the result of the asynchronous method is to use CheckStatus keywords, as shown in the following test: Task.Result

Here, we use await to release the execution thread, allowing API to call asynchronous to complete. After the operation is completed, perform recovery and obtain the results from the task without causing dead locks.

<code class="language-csharp">[Test]
public async void CheckOnceAwaitTest()
{
    Assert.IsTrue(await CheckStatus());
}</code>

In short, in order to effectively handle asynchronous code, please remember that

should be avoided when using asynchronous methods because it may cause dead locks. await keywords should be used to release threads and prevent such problems.

The above is the detailed content of `await` vs. `Task.Result`: When Should You Use Each and Why Does One Cause Deadlocks?. For more information, please follow other related articles on the PHP Chinese website!