Automatisieren des InvokeRequired-Codemusters

Mir ist schmerzlich bewusst geworden, wie oft man das folgende Codemuster in ereignisgesteuerten GUI-Code schreiben muss, wo

private void DoGUISwitch() {
    // cruisin for a bruisin' through exception city
    object1.Visible = true;
    object2.Visible = false;
}

wird:

private void DoGUISwitch() {
    if (object1.InvokeRequired) {
        object1.Invoke(new MethodInvoker(() => { DoGUISwitch(); }));
    } else {
        object1.Visible = true;
        object2.Visible = false;
    }
}

Dies ist ein umständliches Muster in C #, sowohl zum Erinnern als auch zum Tippen. Hat jemand eine Verknüpfung oder ein Konstrukt entwickelt, das dies bis zu einem gewissen Grad automatisiert? Es wäre cool, wenn es eine Möglichkeit gäbe, Objekten, die diese Prüfung durchführen, eine Funktion zuzuweisen, ohne all diese zusätzlichen Arbeiten wie eine object1.InvokeIfNecessary.visible = trueTypverknüpfung ausführen zu müssen.

In früheren Antworten wurde die Unpraktikabilität diskutiert, jedes Mal nur Invoke () aufzurufen, und selbst dann ist die Invoke () -Syntax sowohl ineffizient als auch immer noch umständlich zu handhaben.

Hat jemand irgendwelche Abkürzungen herausgefunden?

Lees Ansatz kann weiter vereinfacht werden

public static void InvokeIfRequired(this Control control, MethodInvoker action)
{
    // See Update 2 for edits Mike de Klerk suggests to insert here.

    if (control.InvokeRequired) {
        control.Invoke(action);
    } else {
        action();
    }
}

Und kann so genannt werden

richEditControl1.InvokeIfRequired(() =>
{
    // Do anything you want with the control here
    richEditControl1.RtfText = value;
    RtfHelpers.AddMissingStyles(richEditControl1);
});

Es ist nicht erforderlich, das Steuerelement als Parameter an den Delegaten zu übergeben. C # erstellt automatisch einen Abschluss .

UPDATE :

Nach mehreren anderen Postern Controlkann verallgemeinert werden als ISynchronizeInvoke:

public static void InvokeIfRequired(this ISynchronizeInvoke obj,
                                         MethodInvoker action)
{
    if (obj.InvokeRequired) {
        var args = new object[0];
        obj.Invoke(action, args);
    } else {
        action();
    }
}

DonBoitnott wies darauf hin, dass im Gegensatz Controlzur ISynchronizeInvokeSchnittstelle ein Objektarray für die InvokeMethode als Parameterliste für die erforderlich ist action.

UPDATE 2

Von Mike de Klerk vorgeschlagene Änderungen (Einfügungspunkt siehe Kommentar im 1. Codeausschnitt):

// When the form, thus the control, isn't visible yet, InvokeRequired  returns false,
// resulting still in a cross-thread exception.
while (!control.Visible)
{
    System.Threading.Thread.Sleep(50);
}

Weitere Informationen zu diesem Vorschlag finden Sie im Kommentar von ToolmakerSteve.

Sie könnten eine Erweiterungsmethode schreiben:

public static void InvokeIfRequired(this Control c, Action<Control> action)
{
    if(c.InvokeRequired)
    {
        c.Invoke(new Action(() => action(c)));
    }
    else
    {
        action(c);
    }
}

Und benutze es so:

object1.InvokeIfRequired(c => { c.Visible = true; });

BEARBEITEN: Wie Simpzon in den Kommentaren hervorhebt, können Sie die Signatur auch ändern in:

public static void InvokeIfRequired<T>(this T c, Action<T> action) 
    where T : Control

Hier ist das Formular, das ich in meinem gesamten Code verwendet habe.

private void DoGUISwitch()
{ 
    Invoke( ( MethodInvoker ) delegate {
        object1.Visible = true;
        object2.Visible = false;
    });
} 

Ich habe dies auf dem Blogeintrag hier basiert . Ich habe diesen Ansatz nicht verfehlt, daher sehe ich keinen Grund, meinen Code mit einer Überprüfung der zu komplizierenInvokeRequired Eigenschaft .

Hoffe das hilft.

Erstellen Sie eine ThreadSafeInvoke.snippet-Datei, und wählen Sie dann einfach die Update-Anweisungen aus, klicken Sie mit der rechten Maustaste und wählen Sie "Surround With ..." oder Strg-K + S:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippet Format="1.0.0" xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <Header>
    <Title>ThreadsafeInvoke</Title>
    <Shortcut></Shortcut>
    <Description>Wraps code in an anonymous method passed to Invoke for Thread safety.</Description>
    <SnippetTypes>
      <SnippetType>SurroundsWith</SnippetType>
    </SnippetTypes>
  </Header>
  <Snippet>
    <Code Language="CSharp">
      <![CDATA[
      Invoke( (MethodInvoker) delegate
      {
          $selected$
      });      
      ]]>
    </Code>
  </Snippet>
</CodeSnippet>

Hier ist eine verbesserte / kombinierte Version der Antworten von Lee, Oliver und Stephan.

public delegate void InvokeIfRequiredDelegate<T>(T obj)
    where T : ISynchronizeInvoke;

public static void InvokeIfRequired<T>(this T obj, InvokeIfRequiredDelegate<T> action)
    where T : ISynchronizeInvoke
{
    if (obj.InvokeRequired)
    {
        obj.Invoke(action, new object[] { obj });
    }
    else
    {
        action(obj);
    }
} 

Die Vorlage ermöglicht flexiblen und Cast-freien Code, der viel besser lesbar ist, während der dedizierte Delegat für Effizienz sorgt.

progressBar1.InvokeIfRequired(o => 
{
    o.Style = ProgressBarStyle.Marquee;
    o.MarqueeAnimationSpeed = 40;
});

Ich würde lieber eine einzelne Instanz einer Methode Delegate verwenden, anstatt jedes Mal eine neue Instanz zu erstellen. In meinem Fall habe ich den Fortschritt und (Info- / Fehler-) Meldungen eines Backroundworkers angezeigt, die große Datenmengen von einer SQL-Instanz kopierten und umwandelten. Nach ungefähr 70000 Fortschritten und Nachrichtenaufrufen funktionierte mein Formular nicht mehr und zeigte neue Nachrichten an. Dies trat nicht auf, als ich anfing, einen einzelnen globalen Instanzdelegaten zu verwenden.

delegate void ShowMessageCallback(string message);

private void Form1_Load(object sender, EventArgs e)
{
    ShowMessageCallback showMessageDelegate = new ShowMessageCallback(ShowMessage);
}

private void ShowMessage(string message)
{
    if (this.InvokeRequired)
        this.Invoke(showMessageDelegate, message);
    else
        labelMessage.Text = message;           
}

void Message_OnMessage(object sender, Utilities.Message.MessageEventArgs e)
{
    ShowMessage(e.Message);
}

Verwendung:

control.InvokeIfRequired(c => c.Visible = false);

return control.InvokeIfRequired(c => {
    c.Visible = value

    return c.Visible;
});

Code:

using System;
using System.ComponentModel;

namespace Extensions
{
    public static class SynchronizeInvokeExtensions
    {
        public static void InvokeIfRequired<T>(this T obj, Action<T> action)
            where T : ISynchronizeInvoke
        {
            if (obj.InvokeRequired)
            {
                obj.Invoke(action, new object[] { obj });
            }
            else
            {
                action(obj);
            }
        }

        public static TOut InvokeIfRequired<TIn, TOut>(this TIn obj, Func<TIn, TOut> func) 
            where TIn : ISynchronizeInvoke
        {
            return obj.InvokeRequired
                ? (TOut)obj.Invoke(func, new object[] { obj })
                : func(obj);
        }
    }
}

Ich mache es gerne ein bisschen anders, ich nenne es gerne "mich", wenn es nötig ist, mit einer Aktion,

    private void AddRowToListView(ScannerRow row, bool suspend)
    {
        if (IsFormClosing)
            return;

        if (this.InvokeRequired)
        {
            var A = new Action(() => AddRowToListView(row, suspend));
            this.Invoke(A);
            return;
        }
         //as of here the Code is thread-safe

Dies ist ein praktisches Muster. Das IsFormClosing ist ein Feld, das ich beim Schließen meines Formulars auf True gesetzt habe, da möglicherweise noch einige Hintergrundthreads ausgeführt werden ...

Sie sollten niemals Code schreiben, der so aussieht:

private void DoGUISwitch() {
    if (object1.InvokeRequired) {
        object1.Invoke(new MethodInvoker(() => { DoGUISwitch(); }));
    } else {
        object1.Visible = true;
        object2.Visible = false;
    }
}

Wenn Sie Code haben, der so aussieht, ist Ihre Anwendung nicht threadsicher. Dies bedeutet, dass Sie Code haben, der DoGUISwitch () bereits von einem anderen Thread aus aufruft. Es ist zu spät, um zu überprüfen, ob es sich um einen anderen Thread handelt. InvokeRequire muss aufgerufen werden, BEVOR Sie DoGUISwitch anrufen. Sie sollten nicht von einem anderen Thread aus auf eine Methode oder Eigenschaft zugreifen.

Referenz: Control.InvokeRequired-Eigenschaft, in der Sie Folgendes lesen können:

Zusätzlich zur InvokeRequired-Eigenschaft gibt es vier Methoden für ein Steuerelement, die threadsicher aufgerufen werden können: Invoke, BeginInvoke, EndInvoke und CreateGraphics, wenn das Handle für das Steuerelement bereits erstellt wurde.

In einer einzelnen CPU-Architektur gibt es kein Problem, aber in einer Architektur mit mehreren CPUs kann ein Teil des UI-Threads dem Prozessor zugewiesen werden, auf dem der aufrufende Code ausgeführt wurde ... und wenn sich dieser Prozessor von dem des UI-Threads unterscheidet wurde dann ausgeführt, wenn der aufrufende Thread beendet wird Windows wird denken, dass der UI-Thread beendet wurde und den Anwendungsprozess beenden, dh Ihre Anwendung wird ohne Fehler beendet.