Скачать или смотреть Understanding the Differences Between Task.Run and Async/Await in C#

Uncover the nuances in using `Task.Run` and `async/await`. Learn when to choose each method for handling parallel tasks in C# .
---
This video is based on the question https://stackoverflow.com/q/68499421/ asked by the user 'variable' ( https://stackoverflow.com/u/1779091/ ) and on the answer https://stackoverflow.com/a/68499847/ provided by the user 'Emperor Eto' ( https://stackoverflow.com/u/4467670/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Is using Task.Run a short hand for async await?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Differences Between Task.Run and Async/Await in C#

In the world of asynchronous programming in C# , developers often find themselves choosing between Task.Run and the async/await pattern. Both are vital tools in the C# programming language, and while they can seem similar, they serve different purposes. This guide aims to clarify these differences and give you insights on when to use each approach effectively.

The Problem: When to Use Task.Run vs Async/Await

When working with tasks in C# , you might wonder whether using Task.Run is a shortcut for using async and await. The simple answer is no. Let's delve deeper into the mechanics of both methods to understand their differences and when each should be used.

Option 1: Using Task.Run

When you invoke tasks like this:

[[See Video to Reveal this Text or Code Snippet]]

You start fn1sync and fn2sync tasks in new threads. These tasks will run in parallel, meaning that as soon as they are called, they will start their execution. However, since there’s no mechanism to wait for these tasks to finish, the control will immediately return to the main thread, allowing any subsequent code to execute without waiting for the tasks.

Key Characteristics of Option 1:

Immediate Execution: Both tasks start running as soon as they're called.

No Waiting: The main thread does not wait for the tasks to finish.

Potentially Parallel: Tasks may run in parallel, but that isn’t guaranteed.

Option 2: Using Async/Await

Unlike the first option, using async and await allows you to hold onto the tasks returned by the asynchronous functions:

[[See Video to Reveal this Text or Code Snippet]]

With this approach, you can perform some actions while the asynchronous methods execute. However, the Task.WaitAll ensures that your program will not proceed until both asynchronous tasks have completed.

Key Characteristics of Option 2:

Managed Execution: You can do other work while waiting for tasks to complete.

Explicit Waiting: The main thread will wait for the tasks to finish due to WaitAll().

Better Control: You have more control over task execution and can leverage the asynchronous pattern more effectively.

Option 3: Combining Task.Run with Async/Await

It's important to consider how Task.Run can be combined with async methods. For example:

[[See Video to Reveal this Text or Code Snippet]]

While at first glance it may appear that this is similar to Option 2, the underlying mechanism works differently, especially in terms of how the tasks behave concerning the main thread control flow.

Understanding the Differences:

Synchronous Code Executing Asynchronously: When wrapping a synchronous method in Task.Run, you can ensure that blocking code does not hinder the rest of your program execution.

Fire and Forget: You might have situations where you want to "fire and forget" an asynchronous operation (e.g., logging), which can be acceptable if the method is well-behaved and won't block the thread.

Conclusion: Choosing the Right Approach

Ultimately, the choice between using Task.Run and the async/await pattern depends on the context of the tasks you are working with.

Use Task.Run when you have synchronous methods that might block execution due to lengthy operations (e.g., legacy code or I/O operations).

Use async/await when dealing with asynchronous methods to maintain control over task scheduling and execution flow.

By understanding these differences, you can write more efficient and responsive C# applications. Happy coding!