Invoke(Délégué)

un objet de contrôle ou de fenêtre dans les formes de Windows est juste un enveloppement autour d'une fenêtre Win32 identifiée par un poignée (parfois appelé HWND). La plupart des choses que vous faites avec le contrôle aboutiront éventuellement à un appel D'API Win32 qui utilise cette poignée. La poignée est détenue par le fil qui l'a créé (typiquement le fil principal), et ne doit pas être manipulée par un autre fil. Si pour une raison quelconque vous avez besoin de faire quelque chose avec le contrôle d'un autre thread, vous pouvez utiliser Invoke pour demander au fil principal de le faire en votre nom.

par exemple, si vous voulez changer le texte d'une étiquette à partir d'un worker thread, vous pouvez faire quelque chose comme ceci:

theLabel.Invoke(new Action(() => theLabel.Text = "hello world from worker thread!"));

si vous voulez modifier un contrôle, il faut le faire dans le thread dans lequel le contrôle a été créé. Cette méthode Invoke vous permet d'exécuter des méthodes dans le thread associé (le thread qui possède la poignée de fenêtre sous-jacente du contrôle).

dans l'exemple ci-dessous thread1 jette une exception parce que SetText1 essaie de modifier textBox1.Du texte à partir d'un autre thread. Mais dans thread2, L'Action dans SetText2 est exécutée dans le thread dans lequel la TextBox a été créée.

private void btn_Click(object sender, EvenetArgs e)
{
    var thread1 = new Thread(SetText1);
    var thread2 = new Thread(SetText2);
    thread1.Start();
    thread2.Start();
}

private void SetText1() 
{
    textBox1.Text = "Test";
}

private void SetText2() 
{
    textBox1.Invoke(new Action(() => textBox1.Text = "Test"));
}

Invoke ((MethodInvoker)delegate{ textBox1.Text = "Test";});

en termes pratiques cela signifie que le délégué est garanti pour être invoqué sur le fil principal. Ceci est important car dans le cas des commandes windows si vous ne mettez pas à jour leurs propriétés sur le thread principal alors vous ne voyez pas le changement, ou la commande soulève une exception.

Le motif est:

void OnEvent(object sender, EventArgs e)
{
   if (this.InvokeRequired)
   {
       this.Invoke(() => this.OnEvent(sender, e);
       return;
   }

   // do stuff (now you know you are on the main thread)
}

cela signifie que le délégué s'exécute sur le thread UI, même si vous appelez cette méthode d'un travailleur de fond ou thread-pool thread. Les éléments UI ont l'affinité de fil - ils aiment parler directement à un fil: le fil UI. Le thread UI est défini comme le thread qui a créé l'instance de contrôle, et est donc associé à la poignée de fenêtre. Mais tout cela est un détail d'implémentation.

le le point clé est: vous appelleriez cette méthode à partir d'un worker thread de sorte que vous pouvez accéder à L'UI (pour changer la valeur dans une étiquette, etc) - Depuis que vous êtes pas autorisé pour faire cela à partir de tout autre thread que le thread UI.

this.Invoke(delegate) assurez-vous que vous appelez le délégué l'argument de this.Invoke() sur le fil principal/fil créé.

je peux dire qu'une règle du pouce n'accède pas à vos contrôles de forme sauf à partir du thread principal.

peut être les lignes suivantes font du sens pour utiliser Invoke ()

    private void SetText(string text)
    {
        // InvokeRequired required compares the thread ID of the
        // calling thread to the thread ID of the creating thread.
        // If these threads are different, it returns true.
        if (this.textBox1.InvokeRequired)
        {   
            SetTextCallback d = new SetTextCallback(SetText);
            this.Invoke(d, new object[] { text });
        }
        else
        {
            this.textBox1.Text = text;
        }
    }

il y a des situations bien que vous créiez un ThreadPool thread(I. e worker thread) il s'exécute sur le thread principal. Il ne créera pas un nouveau filetage coz le filetage principal est disponible pour le traitement d'autres instructions. Donc tout d'abord examiner si le thread courant est le thread principal en utilisant this.InvokeRequired si retourne true le code courant tourne sur worker thread alors appeler ce.Invoke (d, new object[] { text});

sinon mettez directement à jour le contrôle de L'interface utilisateur(Ici vous êtes assurés que vous exécutez le code sur le thread principal.)

délégués sont essentiellement en ligne Action 's ou Func<T> . Vous pouvez déclarer un délégué en dehors de la portée d'une méthode que vous utilisez ou en utilisant une expression lambda ( => ); parce que vous exécutez le délégué dans une méthode, vous l'exécutez sur le thread qui est exécuté pour la fenêtre/application courante qui est le bit en gras.

Lambda exemple

int AddFiveToNumber(int number)
{
  var d = (int i => i + 5);
  d.Invoke(number);
}

cela signifie que le délégué que vous passez est exécuté sur le thread qui a créé l'objet Control (qui est le thread UI).

vous devez appeler cette méthode quand votre application est multi-threadée et vous voulez faire une opération D'UI à partir d'un thread autre que le thread D'UI, parce que si vous essayez juste d'appeler une méthode sur un contrôle à partir d'un thread différent vous obtiendrez un système.InvalidOperationException.