Wie aktualisiere ich die GUI von einem anderen Thread aus?

Question

Welches ist der einfachste Weg, eine Label von einem anderen Thread ?

• Tengo un Form weiterlaufend thread1 und davon ausgehend eröffne ich ein weiteres Thema ( thread2 ).

• Während thread2 einige Dateien verarbeitet, würde ich gerne eine Label sur le Form mit dem aktuellen Status von thread2 Arbeit.

Wie könnte ich das tun?

Answer 1

El einfachste Weg ist eine anonyme Methode, die an Label.Invoke :

// Running on the worker thread
string newText = "abc";
form.Label.Invoke((MethodInvoker)delegate {
    // Running on the UI thread
    form.Label.Text = newText;
});
// Back on the worker thread

Beachten Sie, dass Invoke blockiert die Ausführung, bis sie abgeschlossen ist - das ist synchroner Code. In der Frage wird nicht nach asynchronem Code gefragt, aber es gibt eine Menge Inhalt auf Stack Overflow über das Schreiben von asynchronem Code, wenn Sie es lernen wollen.

Answer 2

Für .NET 2.0 habe ich ein nettes Stück Code geschrieben, das genau das tut, was Sie wollen, und für jede Eigenschaft einer Control :

private delegate void SetControlPropertyThreadSafeDelegate(
    Control control, 
    string propertyName, 
    object propertyValue);

public static void SetControlPropertyThreadSafe(
    Control control, 
    string propertyName, 
    object propertyValue)
{
  if (control.InvokeRequired)
  {
    control.Invoke(new SetControlPropertyThreadSafeDelegate               
    (SetControlPropertyThreadSafe), 
    new object[] { control, propertyName, propertyValue });
  }
  else
  {
    control.GetType().InvokeMember(
        propertyName, 
        BindingFlags.SetProperty, 
        null, 
        control, 
        new object[] { propertyValue });
  }
}

Sagen wir es so:

// thread-safe equivalent of
// myLabel.Text = status;
SetControlPropertyThreadSafe(myLabel, "Text", status);

Wenn Sie .NET 3.0 oder höher verwenden, können Sie die obige Methode als eine Erweiterungsmethode der Control Klasse, was dann den Aufruf zu vereinfachen würde:

myLabel.SetPropertyThreadSafe("Text", status);

UPDATE 05/10/2010:

Für .NET 3.0 sollten Sie diesen Code verwenden:

private delegate void SetPropertyThreadSafeDelegate<TResult>(
    Control @this, 
    Expression<Func<TResult>> property, 
    TResult value);

public static void SetPropertyThreadSafe<TResult>(
    this Control @this, 
    Expression<Func<TResult>> property, 
    TResult value)
{
  var propertyInfo = (property.Body as MemberExpression).Member 
      as PropertyInfo;

  if (propertyInfo == null ||
      !@this.GetType().IsSubclassOf(propertyInfo.ReflectedType) ||
      @this.GetType().GetProperty(
          propertyInfo.Name, 
          propertyInfo.PropertyType) == null)
  {
    throw new ArgumentException("The lambda expression 'property' must reference a valid property on this Control.");
  }

  if (@this.InvokeRequired)
  {
      @this.Invoke(new SetPropertyThreadSafeDelegate<TResult> 
      (SetPropertyThreadSafe), 
      new object[] { @this, property, value });
  }
  else
  {
      @this.GetType().InvokeMember(
          propertyInfo.Name, 
          BindingFlags.SetProperty, 
          null, 
          @this, 
          new object[] { value });
  }
}

die LINQ und Lambda-Ausdrücke verwendet, um eine viel sauberere, einfachere und sicherere Syntax zu ermöglichen:

myLabel.SetPropertyThreadSafe(() => myLabel.Text, status); // status has to be a string or this will fail to compile

Jetzt wird nicht nur der Eigenschaftsname bei der Kompilierung geprüft, sondern auch der Typ der Eigenschaft, so dass es unmöglich ist, einer booleschen Eigenschaft einen String-Wert zuzuweisen und damit eine Laufzeitausnahme zu verursachen.

Leider hält das niemanden davon ab, Dummheiten zu begehen, wie z. B. einen anderen zu überholen. Control Eigenschaft und den Wert, so dass das Folgende problemlos kompiliert werden kann:

myLabel.SetPropertyThreadSafe(() => aForm.ShowIcon, false);

Daher habe ich die Laufzeitprüfungen hinzugefügt, um sicherzustellen, dass die übergebene Eigenschaft tatsächlich zu der Control auf dem die Methode aufgerufen wird. Nicht perfekt, aber immer noch viel besser als die .NET 2.0 Version.

Wenn jemand weitere Vorschläge hat, wie man diesen Code für die Kompilierzeitsicherheit verbessern kann, bitte kommentieren!

Answer 3

Handhabung langer Arbeiten

Desde .NET 4.5 und C# 5.0 sollten Sie Aufgabenbasiertes asynchrones Muster (TAP) zusammen mit asynchron - warten Sie Schlüsselwörter in allen Bereichen (einschließlich der grafischen Benutzeroberfläche):

TAP ist das empfohlene asynchrone Entwurfsmuster für die Neuentwicklung

anstelle von Asynchrones Programmiermodell (APM) y Ereignisbasiertes asynchrones Muster (EAP) (letzteres umfasst die BackgroundWorker-Klasse ).

Die empfohlene Lösung für die Neuentwicklung lautet also:

1. Asynchrone Implementierung eines Event-Handlers (Ja, das ist alles):

   private async void Button_Clicked(object sender, EventArgs e)
   {
       var progress = new Progress<string>(s => label.Text = s);
       await Task.Factory.StartNew(() => SecondThreadConcern.LongWork(progress),
                                   TaskCreationOptions.LongRunning);
       label.Text = "completed";
   }

2. Implementierung des zweiten Threads, der den UI-Thread benachrichtigt:

   class SecondThreadConcern
   {
       public static void LongWork(IProgress<string> progress)
       {
           // Perform a long running work...
           for (var i = 0; i < 10; i++)
           {
               Task.Delay(500).Wait();
               progress.Report(i.ToString());
           }
       }
   }

Beachten Sie das Folgende:

1. Kurzer und sauberer, sequentiell geschriebener Code ohne Callbacks und explizite Threads.
2. Aufgabe anstelle von Thema .
3. asynchron Schlüsselwort, das die Verwendung von warten Sie die wiederum verhindern, dass der Event-Handler den Abschlussstatus erreicht, bis die Aufgabe beendet ist und in der Zwischenzeit den UI-Thread nicht blockiert.
4. Fortschrittsklasse (siehe IProgress Schnittstelle ), die Folgendes unterstützt Trennung der Belange (SoC) Designprinzip und erfordert keine expliziten Dispatcher und Aufrufe. Es verwendet die aktuelle Synchronisationskontext von seinem Erstellungsort (hier der UI-Thread).
5. TaskCreationOptions.LongRunning die darauf hinweist, die Aufgabe nicht in die Warteschlange ThreadPool .

Ausführlichere Beispiele finden Sie unter: Die Zukunft von C#: Gutes kommt zu denen, die "warten von Joseph Albahari .

Siehe auch über UI-Threading-Modell Konzept.

Behandlung von Ausnahmen

Der folgende Ausschnitt ist ein Beispiel für die Behandlung von Ausnahmen und Umschalttasten Enabled um Mehrfachklicks während der Ausführung im Hintergrund zu verhindern.

private async void Button_Click(object sender, EventArgs e)
{
    button.Enabled = false;

    try
    {
        var progress = new Progress<string>(s => button.Text = s);
        await Task.Run(() => SecondThreadConcern.FailingWork(progress));
        button.Text = "Completed";
    }
    catch(Exception exception)
    {
        button.Text = "Failed: " + exception.Message;
    }

    button.Enabled = true;
}

class SecondThreadConcern
{
    public static void FailingWork(IProgress<string> progress)
    {
        progress.Report("I will fail in...");
        Task.Delay(500).Wait();

        for (var i = 0; i < 3; i++)
        {
            progress.Report((3 - i).ToString());
            Task.Delay(500).Wait();
        }

        throw new Exception("Oops...");
    }
}

Answer 4

Variation von Marc Gravell's einfachste solution für .NET 4:

control.Invoke((MethodInvoker) (() => control.Text = "new text"));

Oder verwenden Sie stattdessen Action delegate:

control.Invoke(new Action(() => control.Text = "new text"));

Hier finden Sie einen Vergleich zwischen den beiden: MethodInvoker vs. Aktion für Control.BeginInvoke

Answer 5

Feuer und Vergessen Erweiterungsmethode für .NET 3.5+

using System;
using System.Windows.Forms;

public static class ControlExtensions
{
    /// <summary>
    /// Executes the Action asynchronously on the UI thread, does not block execution on the calling thread.
    /// </summary>
    /// <param name="control"></param>
    /// <param name="code"></param>
    public static void UIThread(this Control @this, Action code)
    {
        if (@this.InvokeRequired)
        {
            @this.BeginInvoke(code);
        }
        else
        {
            code.Invoke();
        }
    }
}

Dies kann mit der folgenden Code-Zeile aufgerufen werden:

this.UIThread(() => this.myLabel.Text = "Text Goes Here");