Async / warte gegen BackgroundWorker

In den letzten Tagen habe ich die neuen Funktionen von .net 4.5 und c # 5 getestet.

Ich mag die neuen Async / Wait-Funktionen. Früher hatte ich BackgroundWorker verwendet , um längere Prozesse im Hintergrund mit reaktionsschneller Benutzeroberfläche zu verarbeiten.

Meine Frage ist: Nach diesen netten neuen Funktionen, wann sollte ich async / await verwenden und wann ein BackgroundWorker ? Welches sind die gemeinsamen Szenarien für beide?

async / await soll Konstrukte wie das ersetzen BackgroundWorker. Sie können es sicherlich verwenden, wenn Sie möchten, aber Sie sollten in der Lage sein, async / await zusammen mit einigen anderen TPL-Tools zu verwenden, um alles zu handhaben, was da draußen ist.

Da beide funktionieren, kommt es auf die persönlichen Vorlieben an, welche Sie wann verwenden. Was geht für Sie schneller ? Was ist für Sie leichter zu verstehen?

Dies ist wahrscheinlich TL; DR für viele, aber ich denke, das Vergleichen awaitmit BackgroundWorkerist wie das Vergleichen von Äpfeln und Orangen, und meine Gedanken dazu folgen:

BackgroundWorkersoll eine einzelne Aufgabe modellieren, die Sie im Hintergrund in einem Thread-Pool-Thread ausführen möchten. async/ awaitist eine Syntax für das asynchrone Warten auf asynchrone Operationen. Diese Operationen können einen Thread-Pool-Thread oder sogar einen anderen Thread verwenden oder nicht . Sie sind also Äpfel und Orangen.

Sie können beispielsweise Folgendes tun mit await:

using (WebResponse response = await webReq.GetResponseAsync())
{
    using (Stream responseStream = response.GetResponseStream())
    {
        int bytesRead = await responseStream.ReadAsync(buffer, 0, buffer.Length);
    }
}

Aber Sie würden wahrscheinlich nie modellieren, dass Sie in einem Hintergrund-Worker wahrscheinlich so etwas in .NET 4.0 (vorher await) tun würden :

webReq.BeginGetResponse(ar =>
{
    WebResponse response = webReq.EndGetResponse(ar);
    Stream responseStream = response.GetResponseStream();
    responseStream.BeginRead(buffer, 0, buffer.Length, ar2 =>
    {
        int bytesRead = responseStream.EndRead(ar2);
        responseStream.Dispose();
        ((IDisposable) response).Dispose();
    }, null);
}, null);

Beachten Sie die Disjunktheit der Entsorgung im Vergleich zwischen den beiden Syntaxen und wie Sie usingohne async/ nicht verwenden können await.

Aber so etwas würden Sie nicht machen BackgroundWorker. BackgroundWorkerdient normalerweise zum Modellieren einer einzelnen Operation mit langer Laufzeit, die die Reaktionsfähigkeit der Benutzeroberfläche nicht beeinträchtigen soll. Beispielsweise:

worker.DoWork += (sender, e) =>
                    {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                        ++i;
                    };
worker.RunWorkerCompleted += (sender, eventArgs) =>
                                {
                                    // TODO: do something on the UI thread, like
                                    // update status or display "result"
                                };
worker.RunWorkerAsync();

Es gibt wirklich nichts, mit dem Sie async / await verwenden können. Es BackgroundWorkererstellt den Thread für Sie.

Jetzt können Sie stattdessen TPL verwenden:

var synchronizationContext = TaskScheduler.FromCurrentSynchronizationContext();
Task.Factory.StartNew(() =>
                      {
                        int i = 0;
                        // simulate lengthy operation
                        Stopwatch sw = Stopwatch.StartNew();
                        while (sw.Elapsed.TotalSeconds < 1)
                            ++i;
                      }).ContinueWith(t=>
                                      {
                                        // TODO: do something on the UI thread, like
                                        // update status or display "result"
                                      }, synchronizationContext);

In diesem Fall TaskSchedulererstellt der Thread den Thread für Sie (unter der Annahme der Standardeinstellung TaskScheduler) und kann awaitwie folgt verwendet werden:

await Task.Factory.StartNew(() =>
                  {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                        ++i;
                  });
// TODO: do something on the UI thread, like
// update status or display "result"

Meiner Meinung nach ist ein wichtiger Vergleich, ob Sie Fortschritte melden oder nicht. Zum Beispiel könnten Sie Folgendes haben BackgroundWorker like:

BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.ProgressChanged += (sender, eventArgs) =>
                            {
                            // TODO: something with progress, like update progress bar

                            };
worker.DoWork += (sender, e) =>
                 {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                    {
                        if ((sw.Elapsed.TotalMilliseconds%100) == 0)
                            ((BackgroundWorker)sender).ReportProgress((int) (1000 / sw.ElapsedMilliseconds));
                        ++i;
                    }
                 };
worker.RunWorkerCompleted += (sender, eventArgs) =>
                                {
                                    // do something on the UI thread, like
                                    // update status or display "result"
                                };
worker.RunWorkerAsync();

Aber Sie würden sich nicht mit etwas davon befassen, weil Sie die Hintergrund-Worker-Komponente auf die Entwurfsoberfläche eines Formulars ziehen und dort ablegen würden - etwas, das Sie mit async/ awaitund Task... nicht tun können, dh Sie haben gewonnen. ' t Erstellen Sie das Objekt manuell, legen Sie die Eigenschaften und die Ereignishandler fest. Sie würden nur in dem Körper der füllen DoWork, RunWorkerCompletedund ProgressChangedEvent - Handler.

Wenn Sie das in async / await "konvertieren" würden, würden Sie etwas tun wie:

     IProgress<int> progress = new Progress<int>();

     progress.ProgressChanged += ( s, e ) =>
        {
           // TODO: do something with e.ProgressPercentage
           // like update progress bar
        };

     await Task.Factory.StartNew(() =>
                  {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                    {
                        if ((sw.Elapsed.TotalMilliseconds%100) == 0)
                        {
                            progress.Report((int) (1000 / sw.ElapsedMilliseconds))
                        }
                        ++i;
                    }
                  });
// TODO: do something on the UI thread, like
// update status or display "result"

Ohne die Möglichkeit, eine Komponente auf eine Designer-Oberfläche zu ziehen, muss der Leser wirklich entscheiden, welche "besser" ist. Aber das ist für mich der Vergleich zwischen awaitund BackgroundWorkernicht, ob Sie auf eingebaute Methoden wie warten können Stream.ReadAsync. Wenn Sie beispielsweise BackgroundWorkerwie vorgesehen verwenden, kann es schwierig sein, die Konvertierung in die Verwendung zu konvertieren await.

Andere Gedanken: http://jeremybytes.blogspot.ca/2012/05/backgroundworker-component-im-not-dead.html

Dies ist eine gute Einführung: http://msdn.microsoft.com/en-us/library/hh191443.aspx Der Abschnitt Threads ist genau das, wonach Sie suchen:

Asynchrone Methoden sollen nicht blockierende Vorgänge sein. Ein Warte-Ausdruck in einer asynchronen Methode blockiert den aktuellen Thread nicht, während die erwartete Aufgabe ausgeführt wird. Stattdessen meldet der Ausdruck den Rest der Methode als Fortsetzung und gibt die Kontrolle an den Aufrufer der asynchronen Methode zurück.

Die Schlüsselwörter async und await führen nicht dazu, dass zusätzliche Threads erstellt werden. Asynchrone Methoden erfordern kein Multithreading, da eine asynchrone Methode nicht in einem eigenen Thread ausgeführt wird. Die Methode wird im aktuellen Synchronisationskontext ausgeführt und verwendet die Zeit im Thread nur, wenn die Methode aktiv ist. Sie können Task.Run verwenden, um CPU-gebundene Arbeit in einen Hintergrundthread zu verschieben. Ein Hintergrundthread hilft jedoch nicht bei einem Prozess, der nur darauf wartet, dass Ergebnisse verfügbar werden.

Der asynchrone Ansatz zur asynchronen Programmierung ist in fast allen Fällen bestehenden Ansätzen vorzuziehen. Insbesondere ist dieser Ansatz für E / A-gebundene Vorgänge besser als BackgroundWorker, da der Code einfacher ist und Sie sich nicht vor Rennbedingungen schützen müssen. In Kombination mit Task.Run ist die asynchrone Programmierung für CPU-gebundene Vorgänge besser als BackgroundWorker, da die asynchrone Programmierung die Koordinierungsdetails für die Ausführung Ihres Codes von der Arbeit trennt, die Task.Run in den Threadpool überträgt.

BackgroundWorker wird in .NET 4.5 ausdrücklich als veraltet gekennzeichnet:

• in dem Buch von Joseph Albahari, Ben Albahari "C # 5.0 auf den Punkt gebracht: Die endgültige Referenz"
• Stephen Clearys Antwort auf meine Frage "War es nicht .NET 4.0 TPL, das asynchrone Muster von APM, EAP und BackgroundWorker überflüssig machte?"

Der MSDN-Artikel "Asynchrone Programmierung mit Async und Await (C # und Visual Basic)" lautet :

Der asynchrone Ansatz zur asynchronen Programmierung ist in fast allen Fällen bestehenden Ansätzen vorzuziehen . Insbesondere ist dieser Ansatz für E / A-gebundene Vorgänge besser als BackgroundWorker, da der Code einfacher ist und Sie sich nicht vor Rennbedingungen schützen müssen. In Kombination mit Task.Run ist die asynchrone Programmierung für CPU-gebundene Vorgänge besser als BackgroundWorker, da die asynchrone Programmierung die Koordinierungsdetails für die Ausführung Ihres Codes von der Arbeit trennt , die Task.Run in den Threadpool überträgt

AKTUALISIEREN

• als Antwort auf den Kommentar von @ eran-otzap :
  "Für IO-gebundene Operationen, weil der Code einfacher ist und Sie sich nicht vor Rennbedingungen schützen müssen" Welche Rennbedingungen können auftreten, können Sie ein Beispiel geben? ""

Diese Frage hätte als separater Beitrag gestellt werden sollen.

Wikipedia hat eine gute Erklärung für Rennbedingungen. Der notwendige Teil davon ist Multithreading und aus demselben MSDN-Artikel Asynchrone Programmierung mit Async und Await (C # und Visual Basic) :

Asynchrone Methoden sollen nicht blockierende Vorgänge sein. Ein Warte-Ausdruck in einer asynchronen Methode blockiert den aktuellen Thread nicht, während die erwartete Aufgabe ausgeführt wird. Stattdessen meldet der Ausdruck den Rest der Methode als Fortsetzung und gibt die Kontrolle an den Aufrufer der asynchronen Methode zurück.

Die Schlüsselwörter async und await führen nicht dazu, dass zusätzliche Threads erstellt werden. Asynchrone Methoden erfordern kein Multithreading, da eine asynchrone Methode nicht in einem eigenen Thread ausgeführt wird. Die Methode wird im aktuellen Synchronisationskontext ausgeführt und verwendet die Zeit im Thread nur, wenn die Methode aktiv ist. Sie können Task.Run verwenden, um CPU-gebundene Arbeit in einen Hintergrundthread zu verschieben. Ein Hintergrundthread hilft jedoch nicht bei einem Prozess, der nur darauf wartet, dass Ergebnisse verfügbar werden.

Der asynchrone Ansatz zur asynchronen Programmierung ist in fast allen Fällen bestehenden Ansätzen vorzuziehen. Insbesondere ist dieser Ansatz für E / A-gebundene Vorgänge besser als BackgroundWorker, da der Code einfacher ist und Sie sich nicht vor Rennbedingungen schützen müssen. In Kombination mit Task.Run ist die asynchrone Programmierung für CPU-gebundene Vorgänge besser als BackgroundWorker, da die asynchrone Programmierung die Koordinierungsdetails für die Ausführung Ihres Codes von der Arbeit trennt, die Task.Run in den Threadpool überträgt

Das heißt: "Die Schlüsselwörter asynchron und warten führen nicht dazu, dass zusätzliche Threads erstellt werden."

Soweit ich mich an meine eigenen Versuche erinnern kann, als ich diesen Artikel vor einem Jahr studierte, könnten Sie, wenn Sie ein Codebeispiel aus demselben Artikel ausgeführt und damit gespielt haben, auf die Situation stoßen, dass es sich um nicht asynchrone Versionen handelt (Sie könnten versuchen, sie zu konvertieren es für dich) auf unbestimmte Zeit blockieren!

Für konkrete Beispiele können Sie auch diese Site durchsuchen. Hier einige Beispiele:

• Aufrufen einer asynchronen Methode mit c # 5.0
• Warum schlägt dieser Code fehl, wenn er über TPL / Tasks ausgeführt wird?
• warten gegen Task.Warten - Deadlock?