Qual è la differenza tra Task.Start / Wait e Async / Await?

Forse mi manca qualcosa, ma qual è la differenza tra fare:

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

Potrei mancare qualcosa

Sei.

qual'è la differenza tra doing Task.Waite await task?

Ordina il tuo pranzo dal cameriere al ristorante. Un momento dopo aver dato il tuo ordine, un amico entra e si siede accanto a te e inizia una conversazione. Ora hai due scelte. Puoi ignorare il tuo amico fino al completamento dell'attività: puoi aspettare fino all'arrivo della tua zuppa e fare nient'altro mentre aspetti. Oppure puoi rispondere al tuo amico e quando il tuo amico smette di parlare, il cameriere ti porterà la tua zuppa.

Task.Waitsi blocca fino al completamento dell'attività: ignori il tuo amico fino al completamento dell'attività. awaitcontinua a elaborare i messaggi nella coda dei messaggi e, quando l'attività è completa, accoda un messaggio che dice "riprendi da dove eri rimasto dopo l'attesa". Parli con il tuo amico e quando c'è un'interruzione nella conversazione arriva la zuppa.

Per dimostrare la risposta di Eric ecco un codice:

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

Questo esempio dimostra la differenza molto chiaramente. Con async / wait il thread chiamante non si bloccherà e continuerà l'esecuzione.

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

Uscita DoAsTask:

[1] Inizio del programma
[1] 1 - Avvio
[1] 2 - Attività avviata
[3] A - Ha iniziato qualcosa
[3] B - Completato qualcosa
[1] 3 - Compito completato con il risultato: 123
[1] Fine del programma

Uscita DoAsAsync:

[1] Inizio del programma
[1] 1 - Avvio
[1] 2 - Attività avviata
[3] A - Ha iniziato qualcosa
[1] Fine del programma
[3] B - Completato qualcosa
[3] 3 - Compito completato con il risultato: 123

Aggiornamento: esempio migliorato mostrando l'ID del thread nell'output.

Wait (), farà eseguire codice potenzialmente asincrono in modo sincronizzato. aspettare non lo farà.

Ad esempio, hai un'applicazione web asp.net. L'utenteA chiama / getUser / 1 endpoint. Il pool di app asp.net sceglierà un thread dal pool di thread (Thread1) e, questo thread effettuerà una chiamata http. Se si esegue Wait (), questo thread verrà bloccato fino alla risoluzione della chiamata http. Durante l'attesa, se UserB chiama / getUser / 2, il pool di app dovrà servire un altro thread (Thread2) per effettuare nuovamente la chiamata http. Hai appena creato (Beh, effettivamente recuperato dal pool di app) un altro thread senza motivo, perché non puoi utilizzare Thread1, è stato bloccato da Wait ().

Se si utilizza wait su Thread1, quindi, SyncContext gestirà la sincronizzazione tra Thread1 e la chiamata http. Semplicemente, avviserà al termine della chiamata http. Nel frattempo, se UserB chiama / getUser / 2, allora utilizzerai di nuovo Thread1 per effettuare una chiamata http, perché è stato rilasciato una volta che l'attesa è stata eseguita. Quindi un'altra richiesta può usarlo, ancora di più. Una volta effettuata la chiamata http (utente1 o utente2), Thread1 può ottenere il risultato e tornare al chiamante (client). Thread1 è stato utilizzato per più attività.

In questo esempio, non molto, praticamente. Se stai aspettando un'attività che ritorni su un thread diverso (come una chiamata WCF) o rinunci al controllo sul sistema operativo (come File IO), waitit utilizzerà meno risorse di sistema non bloccando un thread.

Nell'esempio sopra, è possibile utilizzare "TaskCreationOptions.HideScheduler" e modificare notevolmente il metodo "DoAsTask". Il metodo in sé non è asincrono, come accade con "DoAsAsync" perché restituisce un valore "Task" ed è contrassegnato come "asincrono", creando diverse combinazioni, ecco come mi dà esattamente lo stesso che usare "async / wait" :

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