直接调用没有 Async/Await 的任务实际上做了什么？ [关闭]

Question

以应用程序调用 DoThis() 函数的简单示例为例：

        public Task DoThis()
        {
            DoThisSub(); //Why is this being run?
            Task.Delay(100); //Yet..... Why is this ignored?
            Console.WriteLine("This is run immediately without delay");
            return Task.CompletedTask;
        }

        public Task DoThisSub()
        {
            Console.WriteLine("Yes I am being run!");
            return Task.CompletedTask;
        }

为什么调用 DoThisSub 而不是调用 Task.Delay？

Answer 1

为什么调用了 DoThisSub 而没有调用 Task.Delay？

他们都被称为。它们都返回任务实例，它们都被忽略了。

这里没有“单独的线程”；所有方法都在同一个线程上运行。

Answer 2

Task.Delay 方法创建了一个新任务，该任务将在一段时间后完成，因此不会被忽略。 （参考：https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.delay?view=net-5.0）

它正在被调用并且另一个线程可能会运行延迟（要确切知道哪个线程将运行任务取决于许多因素），但是因为调用线程没有等待 Task.Delay方法它会立即继续处理下一行。

如果您希望调用线程等待 Task.Delay 方法，有几个选项：

1. 使 DoThis 方法异步并等待 Task.Delay 方法。

   public async Task DoThis()
   {
       DoThisSub();
       await Task.Delay(100);
       Console.WriteLine("This will not be called immediately after the Task.Delay(100)");
       return Task.CompletedTask;
   }
   

2. 在Task.Delay()

   之后调用Wait()方法

   public Task DoThis()
   {
       DoThisSub();
       Task.Delay(100).Wait();
       Console.WriteLine("This will not be called immediately after the Task.Delay(100)");
       return Task.CompletedTask;
   }
   

我强烈建议您阅读 microsoft async/await 文档。 （参考：https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/）

解决 cmets 中的问题：

为什么 Task.Delay 在单独的线程上运行，而 DoThisSub() 不是

DoThisSub() 方法只是一个返回任务的常规方法。并非所有返回 Task 的方法实际上都在新线程上运行。为此，该方法需要在新任务上实际运行代码，如下例所示：

    public Task DoThisSub()
    {
        return Task.Run(() => 
        {
            Console.WriteLine("Yes I am being run on a new thread!");
        });
    }

Answer 3

它不被忽略了！它在单独的线程上调用，并且由于您不是 awaiting 结果控制立即移动到下一条语句

Answer 4

Task 和 Thread 之间没有直接关系。 Task-await-async 只是 Asynchronous-task + EventHandler 的简化形式。 （相关概念：Events、Delegates、Lambda expressions）。

例如，虽然我们现在很随意地使用 flat code 如下，

async {
    Debug.WriteLine("Before");
    await Task.Delay(100);

    Debug.WriteLine("After");
    :
    Debug.WriteLine("The End");
}

曾几何时（可能在 .NET3.x 或早期 .NET4.x 时代，请参阅 C# Version History），没有等待异步语法。只有 AsynchronousDelayTaskWorker 类或其他东西（1）接受事件处理程序，（2）异步运行耗时的任务，然后（3）最后触发事件。为了使用这种设备，程序员必须编写如下复杂的结构化代码。

{
   Debug.WriteLine("Before");
   var worker = new AsynchronousDelayTaskWorker();
   worker.SetCompletedEventHandler(new CompletedEventHander(()=>
   {
       // Whether this handler is dispatched on the original thread or not
       // depends on worker's implementation. 

       Debug.WriteLine("After");
       :
       Debug.WriteLine("The End");
   }));
   worker.RunAsync();
}

但是在task-async-await were introduced in .NET4.5之后，这样的代码就可以写成如下这样一个简洁干净的方式了。

async {

    Debug.WriteLine("Before");
    await Task.Delay(100);

    // Following codes are actually placed in event handler.
    Debug.WriteLine("After");
    :
    Debug.WriteLine("The End");
}

——C#程序员从此过上了幸福的生活。

使用不带等待的任务几乎等同于在不注册事件处理程序的情况下运行旧的异步任务。该任务在某处异步运行（在许多情况下在后台线程中）。 在任务完成后无法运行另一个代码，因为不知道任务何时完成/完成，没有事件处理程序。

由于任务只是对象，不干扰后续代码，所有的行都直接运行。

{
    Debug.WriteLine("Before");

    // The following worker runs somewhere 
    // as the raw Task.Delay(100) does.
    var worker = new AsynchronousDelayTaskWorker();
    worker.RunAsync(); 

    // Following codes run immediately.
    Debug.WriteLine("After"); 
    :
    Debug.WriteLine("The End");
}