Quelle est la différence entre Task.Start / Wait et Async / Await?

Il me manque peut-être quelque chose, mais quelle est la différence entre faire:

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

Il me manque peut-être quelque chose

Vous êtes.

quelle est la difference entre faire Task.Waitet await task?

Vous commandez votre déjeuner au serveur du restaurant. Un moment après avoir donné votre commande, un ami entre et s'assoit à côté de vous et commence une conversation. Vous avez maintenant deux choix. Vous pouvez ignorer votre ami jusqu'à ce que la tâche soit terminée - vous pouvez attendre que votre soupe arrive et ne rien faire d'autre pendant que vous attendez. Ou vous pouvez répondre à votre ami, et lorsque votre ami cesse de parler, le serveur vous apportera votre soupe.

Task.Waitbloque jusqu'à ce que la tâche soit terminée - vous ignorez votre ami jusqu'à ce que la tâche soit terminée. awaitcontinue de traiter les messages dans la file d'attente de messages, et lorsque la tâche est terminée, il met en file d'attente un message qui dit "reprendre là où vous vous étiez arrêté après cette attente". Vous parlez à votre ami, et quand il y a une pause dans la conversation, la soupe arrive.

Pour démontrer la réponse d'Eric, voici un code:

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

Cet exemple montre très clairement la différence. Avec async / wait, le thread appelant ne se bloquera pas et continuera à s'exécuter.

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

Sortie DoAsTask:

[1] Début du programme
[1] 1 - Démarrage
[1] 2 - La tâche a commencé
[3] A - A commencé quelque chose
[3] B - A terminé quelque chose
[1] 3 - Tâche terminée avec résultat: 123
[1] Fin du programme

Sortie DoAsAsync:

[1] Début du programme
[1] 1 - Démarrage
[1] 2 - La tâche a commencé
[3] A - A commencé quelque chose
[1] Fin du programme
[3] B - A terminé quelque chose
[3] 3 - Tâche terminée avec résultat: 123

Mise à jour: exemple amélioré en affichant l'ID de thread dans la sortie.

Wait (), provoquera l'exécution de code potentiellement asynchrone de manière synchronisée. attendre ne sera pas.

Par exemple, vous disposez d'une application Web asp.net. UserA appelle / getUser / 1 endpoint. Le pool d'applications asp.net choisira un thread dans le pool de threads (Thread1) et ce thread fera un appel http. Si vous faites Wait (), ce thread sera bloqué jusqu'à la résolution de l'appel http. Pendant qu'il attend, si UserB appelle / getUser / 2, le pool d'applications devra servir un autre thread (Thread2) pour effectuer à nouveau un appel http. Vous venez de créer (enfin, récupéré du pool d'applications en fait) un autre thread sans raison, car vous ne pouvez pas utiliser Thread1, il a été bloqué par Wait ().

Si vous utilisez wait sur Thread1, SyncContext gèrera la synchronisation entre Thread1 et l'appel http. Simplement, il vous avertira une fois l'appel http terminé. Pendant ce temps, si UserB appelle / getUser / 2, vous utiliserez à nouveau Thread1 pour passer un appel http, car il a été libéré une fois que wait a été atteint. Ensuite, une autre demande peut l'utiliser, encore plus. Une fois l'appel http terminé (utilisateur1 ou utilisateur2), Thread1 peut obtenir le résultat et revenir à l'appelant (client). Thread1 a été utilisé pour plusieurs tâches.

Dans cet exemple, pas beaucoup, pratiquement. Si vous attendez une tâche qui revient sur un thread différent (comme un appel WCF) ou qui abandonne le contrôle au système d'exploitation (comme File IO), wait utilisera moins de ressources système en ne bloquant pas un thread.

Dans l'exemple ci-dessus, vous pouvez utiliser "TaskCreationOptions.HideScheduler" et modifier considérablement la méthode "DoAsTask". La méthode elle-même n'est pas asynchrone, comme cela arrive avec "DoAsAsync" car elle retourne une valeur "Task" et est marquée comme "async", faisant plusieurs combinaisons, c'est ainsi qu'elle me donne exactement la même chose qu'en utilisant "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;
}