Aufräumen von Code mit InvokeRequired

Gut wie über dieses:

public static class ControlHelpers
{
    public static void InvokeIfRequired<T>(this T control, Action<T> action) where T : ISynchronizeInvoke
    {
        if (control.InvokeRequired)
        {
            control.Invoke(new Action(() => action(control)), null);
        }
        else
        {
            action(control);
        }
    }
}

Verwenden Sie es wie diese:

private void UpdateSummary(string text)
{
    summary.InvokeIfRequired(s => { s.Text = text });
}

InformationsquelleAutor der Antwort John Gietzen

, Die ich gelesen habe über die Argumente hin und her über das hinzufügen von ein Logik-check, um herauszufinden, ob die invoke-sollte verwendet werden, IFF, wenn Sie nicht auf dem UI-thread und nicht im UI-thread selbst. Ich schrieb eine Klasse, die untersucht, wie die Zeit zum ausführen (via Stoppuhr) von verschiedenen Methoden, um eine grobe Einschätzung der Effizienz einer Methode über eine andere stellen.

Werden die Ergebnisse möglicherweise überraschend für einige von Euch (diese tests wurden ausgeführt über die Form.Gezeigt event):

     //notice that we are updating the form's title bar 10,000 times
     //directly on the UI thread
     TimedAction.Go
     (
        "Direct on UI Thread",
        () =>
        {
           for (int i = 0; i < 10000; i++)
           {
              this.Text = "1234567890";
           }
        }
     );

     //notice that we are invoking the update of the title bar
     //(UI thread -> [invoke] -> UI thread)
     TimedAction.Go
     (
        "Invoke on UI Thread",
        () =>
        {
           this.Invoke
           (
              new Action
              (
                 () =>
                 {
                    for (int i = 0; i < 10000; i++)
                    {
                       this.Text = "1234567890";
                    }
                 }
              )
           );
        }
     );

     //the following is invoking each UPDATE on the UI thread from the UI thread
     //(10,000 invokes)
     TimedAction.Go
     (
        "Separate Invoke on UI Thread",
        () =>
        {
           for (int i = 0; i < 10000; i++)
           {
              this.Invoke
              (
                 new Action
                 (
                    () =>
                    {
                       this.Text = "1234567890";
                    }
                 )
              );
           }
        }
     );

Ergebnisse sind wie folgt:

• TimedAction::Go()+0 - Debug: [DEBUG] Stoppuhr [Direkt auf der UI-Thread]: 300ms
• TimedAction::Go()+0 - Debug: [DEBUG] Stoppuhr [Aufrufen auf UI-Thread]: 299ms
• TimedAction::Go()+0 - Debug: [DEBUG] Stoppuhr [Separaten Aufrufen auf UI-Thread]: 649ms

Mein Fazit ist, dass Sie können sicher aufrufen, zu jeder Zeit, unabhängig davon, ob Sie auf dem UI-thread oder ein worker-thread, ohne signifikanten overhead der Schleife zurück über das Nachrichtensystem. Allerdings, die meisten von der Arbeit AUF dem UI-thread statt, die viele Aufrufe im UI-thread (via Invoke()) ist von Vorteil und verbessern die Effizienz erheblich.

InformationsquelleAutor der Antwort Michael

Ich bin nicht davon überzeugt, dass Control.Invoke ist die beste Wahl für die Aktualisierung der Benutzeroberfläche. Ich kann nicht sicher sagen, in Ihrem Fall, weil ich nicht wissen, die Umstände, in denen UpdateSummary in genannt. Allerdings, wenn Sie anrufen, wird es regelmäßig als ein Mechanismus zum anzeigen von Informationen über den Fortschritt (das ist der Eindruck, den ich aus dem code-snippet), dann gibt es in der Regel eine bessere option. Dass option ist, um den UI-thread-Umfrage für den status anstatt die worker-thread schieben.

Die Gründe, warum die polling-Ansatz sollte geprüft werden, in diesem Fall ist, weil:

• Es bricht die enge Kopplung zwischen der UI und der worker-threads, die Control.Invoke auferlegt werden.
• Es legt die Verantwortung für die Aktualisierung der UI-thread auf die UI-thread, in dem es gehören sollte trotzdem.
• Der UI-thread wird diktieren, Wann und wie oft die Aktualisierung erfolgen soll.
• Es gibt kein Risiko der UI-message-Pumpe überrollt, als wäre der Fall mit der Marshalling-Techniken initiiert durch den worker-thread.
• Der worker-thread nicht zu warten, für die Bestätigung, dass das update durchgeführt wurde, bevor Sie mit Ihrer nächsten Schritte (dh. Sie bekommen mehr Durchsatz auf der Benutzeroberfläche und worker-threads).

So erstellen Sie eine System.Windows.Forms.Timer dass überprüft regelmäßig, ob der text angezeigt werden, auf die Control anstelle der Einleitung der push von den worker-thread. Wieder, ohne zu wissen, Ihre genauen Anforderungen, die ich nicht bereit bin zu sagen, dies ist definitiv die Richtung, die Sie gehen müssen, aber in den meisten vielen Fällen ist besser als die Control.Invoke option.

Offensichtlich ist dieser Ansatz eliminiert die Notwendigkeit, die InvokedRequired prüfen Sie völlig. Nevermind die Tatsache, dass es vereinfacht alle anderen Aspekte des UI - /worker-thread-Interaktion.

InformationsquelleAutor der Antwort Brian Gideon

Kann ich nicht kommentieren, aber hoffentlich jemand sieht, dass dieses und fügen Sie es auf die akzeptierte Antwort, die sonst vor Ort auf.

control.Invoke(new Action(() => action(control))); Lesen sollten

control.Invoke(new Action(() => action(control)), null);

Als schriftlich, die akzeptierte Antwort wird nicht kompilieren, da ISynchronizeInvoke.Invoke() keine überladung mit nur 1 argument wie Control.Invoke() tut.

Eine andere Sache ist, dass die Nutzung sein könnte klarer

summary.InvokeIfRequired(c => { summary.Text = text; }); anstatt wie geschrieben
summary.InvokeIfRequired(c => { textBox.Text = text });

InformationsquelleAutor der Antwort Joseph A