¿Cuál es la diferencia entre Task.Start / Wait y Async / Await?

Puede que me falte algo, pero ¿cuál es la diferencia entre hacer:

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);
}

Puedo estar olvidando algo

Usted está.

¿Cuál es la diferencia entre hacer Task.Waity await task?

Pides tu almuerzo del camarero en el restaurante. Un momento después de dar su orden, un amigo entra y se sienta a su lado y comienza una conversación. Ahora tienes dos opciones. Puede ignorar a su amigo hasta que se complete la tarea; puede esperar hasta que llegue su sopa y no hacer nada más mientras espera. O puede responder a su amigo, y cuando su amigo deja de hablar, el camarero le traerá su sopa.

Task.Waitbloquea hasta que se complete la tarea: ignora a su amigo hasta que se complete la tarea. awaitsigue procesando mensajes en la cola de mensajes, y cuando se completa la tarea, pone en cola un mensaje que dice "retomar donde lo dejó después de esperar". Hablas con tu amigo, y cuando hay un descanso en la conversación, llega la sopa.

Para demostrar la respuesta de Eric aquí hay un código:

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);
}

Este ejemplo demuestra la diferencia muy claramente. Con async / wait, el hilo de llamada no se bloqueará y continuará ejecutándose.

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);
}

Salida de DoAsTask:

[1] Inicio del programa
[1] 1 - Inicio
[1] 2 - Tarea iniciada
[3] A - Comenzó algo
[3] B - Completado algo
[1] 3 - Tarea completada con el resultado: 123
[1] Fin del programa

Salida DoAsAsync:

[1] Inicio del programa
[1] 1 - Inicio
[1] 2 - Tarea iniciada
[3] A - Comenzó algo
[1] Fin del programa
[3] B - Completado algo
[3] 3 - Tarea completada con el resultado: 123

Actualización: ejemplo mejorado al mostrar la ID del hilo en la salida.

Wait (), hará que se ejecute el código potencialmente asíncrono de manera sincronizada. esperar no lo hará.

Por ejemplo, tiene una aplicación web asp.net. UsuarioA llama / getUser / 1 punto final. El grupo de aplicaciones asp.net elegirá un hilo del grupo de hilos (Thread1) y este hilo hará una llamada http. Si espera Wait (), este hilo se bloqueará hasta que se resuelva la llamada http. Mientras está esperando, si UserB llama / getUser / 2, entonces, el grupo de aplicaciones necesitará servir otro hilo (Thread2) para volver a hacer una llamada http. Acaba de crear (Bueno, en realidad se obtuvo del grupo de aplicaciones) otro subproceso sin razón, porque no puede usar Thread1 que fue bloqueado por Wait ().

Si usa await en Thread1, SyncContext gestionará la sincronización entre Thread1 y la llamada http. Simplemente, notificará una vez que se realice la llamada http. Mientras tanto, si UserB llama / getUser / 2, entonces usará Thread1 nuevamente para hacer una llamada http, porque fue liberada una vez que estaba esperando que la golpearan. Luego, otra solicitud puede usarlo, aún más. Una vez que se realiza la llamada http (usuario1 o usuario2), Thread1 puede obtener el resultado y regresar a la persona que llama (cliente). Thread1 se usó para múltiples tareas.

En este ejemplo, no mucho, prácticamente. Si está esperando una Tarea que regrese en un subproceso diferente (como una llamada WCF) o ceda el control al sistema operativo (como Archivo IO), esperar usará menos recursos del sistema al no bloquear un subproceso.

En el ejemplo anterior, puede usar "TaskCreationOptions.HideScheduler" y modificar en gran medida el método "DoAsTask". El método en sí no es asíncrono, como sucede con "DoAsAsync" porque devuelve un valor de "Tarea" y está marcado como "asíncrono", haciendo varias combinaciones, así es como me da exactamente lo mismo que usar "asíncrono / esperar" :

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;
}