What are the key differences between `await Task.Run(); return;` and `return Task.Run()` in asynchronous programming?

In -depth discussion of the key differences in the asynchronous programming

and await Task.Run(); return; return Task.Run() In the field of asynchronous programming, clever use of

and

keywords can significantly improve the readability and performance of the code. However, a subtle question appears: is there a fundamental difference between async and await? To clarify this issue, we will discuss the operation details of these two methods. await Task.Run(); return; return Task.Run() The differences in the abnormal communication mechanism

A key difference is the abnormal way of communication. The abnormalities encountered in the asynchronous method will be passed on to the back, and through the

,

, Task or await task observing the sleep state before the task.Wait(). Even if the abnormality comes from the synchronization part of the method, the situation is the case. task.Result task.GetAwaiter().GetResult() Let's take a look at the following scenes: Task

If is called with

together, it will output:

static async Task OneTestAsync(int n)
{
    await Task.Delay(n);
}

static Task AnotherTestAsync(int n)
{
    return Task.Delay(n);
}

static void DoTestAsync(Func<int, Task> whatTest, int n)
{
    Task task = null;
    try
    {
        task = whatTest(n);
        Console.Write("Press enter to continue");
        Console.ReadLine();
        task.Wait();
    }
    catch (Exception ex)
    {
        Console.Write("Error: " + ex.Message);
    }
}

DoTestAsync It is worth noting that OneTestAsync can cause abnormalities during verification. However, when <，> is used, the behavior of abnormal communication is different, as shown below:

<code>Press enter to continue
Error: One or more errors occurred.
Error: 2nd</code>

<步> The execution of asynchronous and non -step Delay(-2) AnotherTestAsync

<> Methods Promote asynchronous execution. The execution of the allowable method and asynchronous operations (such as network I/O or file access) execution at the same time. On the contrary,

<code>Error: The value needs to be either -1 (signifying an infinite timeout), 0 or a positive integer.
Parameter name: millisecondsDelayError: 1st</code>

Start a non -different step calculation, and the method execution will be suspended until the task is completed.

The influence of synchronous context

The asynchronous operation is performed in the synchronous context, the context determines how to operate and when to communicate with the UI element. async/await The operating symbol is inherently processed synchronized context to ensure that the subsequent code is called in the correct context. If there is no , this responsibility will fall on the programmer, which may lead to the problem of dead locks or thread synchronization. return Task.Run()

In short, the choice of

and depends on the required abnormal communication behavior, asynchronous and non -step enforcement, and synchronous context considerations. The former is usually more suitable for more accurate abnormal treatment and correct synchronization context management, while the latter can simplify the code structure in some cases, but must be used with caution to avoid potential traps.

The above is the detailed content of What are the key differences between `await Task.Run(); return;` and `return Task.Run()` in asynchronous programming?. For more information, please follow other related articles on the PHP Chinese website!