Task.Start / Wait和Async / Await有什么区别？

我可能会丢失一些东西，但是这样做之间有什么区别：

public void MyMethod()
{
  Task t = Task.Factory.StartNew(DoSomethingThatTakesTime);
  t.Wait();
  UpdateLabelToSayItsComplete();
}

public async void MyMethod()
{
  var result = Task.Factory.StartNew(DoSomethingThatTakesTime);
  await result;
  UpdateLabelToSayItsComplete();
}

private void DoSomethingThatTakesTime()
{
  Thread.Sleep(10000);
}

我可能会缺少一些东西

你是。

Task.Wait和和有await task什么区别？

您从餐厅的服务员那里订购午餐。下订单后的片刻，一个朋友走进来，坐在您旁边，开始对话。现在，您有两个选择。在任务完成之前，您可以忽略您的朋友-您可以等到汤汁到达时再等待，而无需执行其他操作。或者您可以回复您的朋友，当您的朋友停止讲话时，服务员会带您汤。

Task.Wait直到任务完成才阻止-您忽略您的朋友，直到任务完成。await继续在消息队列中处理消息，当任务完成时，它使一条消息排队，该消息为“在等待后从您离开的地方提起”。您与朋友交谈，谈话中断时，汤就到了。

为了演示Eric的答案，这里是一些代码：

public void ButtonClick(object sender, EventArgs e)
{
  Task t = new Task.Factory.StartNew(DoSomethingThatTakesTime);
  t.Wait();  
  //If you press Button2 now you won't see anything in the console 
  //until this task is complete and then the label will be updated!
  UpdateLabelToSayItsComplete();
}

public async void ButtonClick(object sender, EventArgs e)
{
  var result = Task.Factory.StartNew(DoSomethingThatTakesTime);
  await result;
  //If you press Button2 now you will see stuff in the console and 
  //when the long method returns it will update the label!
  UpdateLabelToSayItsComplete();
}

public void Button_2_Click(object sender, EventArgs e)
{
  Console.WriteLine("Button 2 Clicked");
}

private void DoSomethingThatTakesTime()
{
  Thread.Sleep(10000);
}

此示例非常清楚地说明了差异。通过异步/等待，调用线程将不会阻塞并继续执行。

static void Main(string[] args)
{
    WriteOutput("Program Begin");
    // DoAsTask();
    DoAsAsync();
    WriteOutput("Program End");
    Console.ReadLine();
}

static void DoAsTask()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime);
    WriteOutput("2 - Task started");
    t.Wait();
    WriteOutput("3 - Task completed with result: " + t.Result);
}

static async Task DoAsAsync()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime);
    WriteOutput("2 - Task started");
    var result = await t;
    WriteOutput("3 - Task completed with result: " + result);
}

static int DoSomethingThatTakesTime()
{
    WriteOutput("A - Started something");
    Thread.Sleep(1000);
    WriteOutput("B - Completed something");
    return 123;
}

static void WriteOutput(string message)
{
    Console.WriteLine("[{0}] {1}", Thread.CurrentThread.ManagedThreadId, message);
}

DoAsTask输出：

[1]程序开始
[1] 1-开始
[1] 2-任务开始
[3] A-开始某件事
[3] B-完成了某件事
[1] 3-任务完成，结果：123
[1]程序结束

DoAsAsync输出：

[1]程序开始
[1] 1-开始
[1] 2-任务开始
[3] A-开始某件事
[1]程序结束
[3] B-完成了某件事
[3] 3-任务完成，结果：123

更新：通过在输出中显示线程ID的改进示例。

Wait（），将导致以同步方式运行潜在的异步代码。等待不会。

例如，您有一个asp.net Web应用程序。UserA调用/ getUser / 1端点。asp.net应用程序池将从线程池（Thread1）中选择一个线程，并且该线程将进行http调用。如果执行Wait（），则该线程将被阻塞，直到http调用解决。在等待期间，如果UserB调用/ getUser / 2，则应用程序池将需要提供另一个线程（Thread2）来再次进行http调用。您只是无缘无故地创建了（嗯，实际上是从应用程序池中获取的）另一个线程，因为您无法使用Thread1，该线程已被Wait（）阻止。

如果在Thread1上使用await，则SyncContext将管理Thread1和http调用之间的同步。简单来说，它将在HTTP调用完成后通知。同时，如果UserB调用/ getUser / 2，则您将再次使用Thread1进行http调用，因为它在等待命中后即被释放。然后另一个请求可以使用它，甚至更多。完成http调用（user1或user2）后，Thread1可以获取结果并返回到调用方（客户端）。Thread1用于多个任务。

在这个例子中，实际上没有太多。如果您正在等待一个在不同线程上返回的任务（例如WCF调用），或者将控制权交给了操作系统（例如文件IO），则等待将通过不阻塞线程来减少系统资源。

在上面的示例中，可以使用“ TaskCreationOptions.HideScheduler”，并大大修改“ DoAsTask”方法。该方法本身不是异步的，因为它与“ DoAsAsync”一起发生，因为它返回一个“ Task”值并被标记为“ async”，进行了几种组合，这给了我与使用“ async / await”完全相同的方式：

static Task DoAsTask()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime, TaskCreationOptions.HideScheduler); //<-- HideScheduler do the magic

    TaskCompletionSource<int> tsc = new TaskCompletionSource<int>();
    t.ContinueWith(tsk => tsc.TrySetResult(tsk.Result)); //<-- Set the result to the created Task

    WriteOutput("2 - Task started");

    tsc.Task.ContinueWith(tsk => WriteOutput("3 - Task completed with result: " + tsk.Result)); //<-- Complete the Task
    return tsc.Task;
}