Was ist der Unterschied zwischen Task.Start / Wait und Async / Await?

Ich vermisse vielleicht etwas, aber was ist der Unterschied zwischen:

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

Mir fehlt vielleicht etwas

Du bist.

Was ist der Unterschied zwischen tun Task.Waitund await task?

Sie bestellen Ihr Mittagessen beim Kellner im Restaurant. Einen Moment nach der Bestellung kommt ein Freund herein, setzt sich neben Sie und beginnt ein Gespräch. Jetzt haben Sie zwei Möglichkeiten. Sie können Ihren Freund ignorieren, bis die Aufgabe erledigt ist - Sie können warten, bis Ihre Suppe eintrifft, und nichts anderes tun, während Sie warten. Oder Sie können Ihrem Freund antworten, und wenn Ihr Freund aufhört zu reden, bringt Ihnen der Kellner Ihre Suppe.

Task.Waitblockiert, bis die Aufgabe abgeschlossen ist - Sie ignorieren Ihren Freund, bis die Aufgabe abgeschlossen ist. awaitVerarbeitet weiterhin Nachrichten in der Nachrichtenwarteschlange. Wenn die Aufgabe abgeschlossen ist, wird eine Nachricht in die Warteschlange gestellt, die besagt, dass Sie dort weitermachen, wo Sie nach dem Warten aufgehört haben. Sie sprechen mit Ihrem Freund, und wenn das Gespräch unterbrochen wird, kommt die Suppe an.

Um Erics Antwort hier zu demonstrieren, gibt es einen 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);
}

Dieses Beispiel zeigt den Unterschied sehr deutlich. Mit async / await blockiert der aufrufende Thread nicht und wird weiter ausgeführt.

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-Ausgabe:

[1] Programmbeginn
[1] 1 - Starten
[1] 2 - Aufgabe gestartet
[3] A - Etwas gestartet
[3] B - Etwas abgeschlossen
[1] 3 - Aufgabe mit Ergebnis abgeschlossen: 123
[1] Programmende

DoAsAsync-Ausgabe:

[1] Programmbeginn
[1] 1 - Starten
[1] 2 - Aufgabe gestartet
[3] A - Etwas gestartet
[1] Programmende
[3] B - Etwas abgeschlossen
[3] 3 - Aufgabe mit Ergebnis abgeschlossen: 123

Update: Verbessertes Beispiel durch Anzeigen der Thread-ID in der Ausgabe.

Wait () führt dazu, dass möglicherweise asynchroner Code synchron ausgeführt wird. Warten wird nicht.

Sie haben beispielsweise eine asp.net-Webanwendung. UserA ruft den Endpunkt / getUser / 1 auf. Der asp.net-App-Pool wählt einen Thread aus dem Thread-Pool (Thread1) aus und dieser Thread führt einen http-Aufruf durch. Wenn Sie Wait () ausführen, wird dieser Thread blockiert, bis der http-Aufruf aufgelöst wird. Wenn UserB / getUser / 2 aufruft, muss der App-Pool während des Wartens einen anderen Thread (Thread2) bereitstellen, um erneut einen http-Aufruf durchzuführen. Sie haben gerade einen anderen Thread ohne Grund erstellt (tatsächlich aus dem App-Pool abgerufen), da Sie Thread1 nicht verwenden können. Er wurde von Wait () blockiert.

Wenn Sie "Warten" für Thread1 verwenden, verwaltet SyncContext die Synchronisierung zwischen Thread1 und http-Aufruf. Es wird einfach benachrichtigt, sobald der http-Aufruf abgeschlossen ist. Wenn UserB / getUser / 2 aufruft, verwenden Sie Thread1 erneut, um einen http-Aufruf zu tätigen, da er veröffentlicht wurde, sobald er auf einen Treffer wartet. Dann kann eine andere Anfrage es noch weiter nutzen. Sobald der http-Aufruf abgeschlossen ist (Benutzer1 oder Benutzer2), kann Thread1 das Ergebnis abrufen und zum Anrufer (Client) zurückkehren. Thread1 wurde für mehrere Aufgaben verwendet.

In diesem Beispiel praktisch nicht viel. Wenn Sie auf eine Aufgabe warten, die für einen anderen Thread zurückgegeben wird (z. B. einen WCF-Aufruf) oder die Steuerung an das Betriebssystem abgibt (z. B. Datei-E / A), verbraucht wait weniger Systemressourcen, indem ein Thread nicht blockiert wird.

Im obigen Beispiel können Sie "TaskCreationOptions.HideScheduler" verwenden und die "DoAsTask" -Methode stark ändern. Die Methode selbst ist nicht asynchron, wie es bei "DoAsAsync" der Fall ist, da sie einen "Task" -Wert zurückgibt und als "async" markiert ist, wobei mehrere Kombinationen vorgenommen werden. Auf diese Weise erhalte ich genau das gleiche wie bei der Verwendung von "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;
}