Control.Invoke Methode

Referenz

Definition

Namespace:: System.Windows.Forms

Assembly:: System.Windows.Forms.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Führt einen Delegaten im Thread aus, der dem zugrunde liegenden Fensterhandle des Steuerelements gehört.

Überlädt

Invoke(Action)	Führt den angegebenen Delegaten im Thread aus, der dem zugrunde liegenden Fensterhandle des Steuerelements gehört.
Invoke(Delegate)	Führt den angegebenen Delegaten im Thread aus, der dem zugrunde liegenden Fensterhandle des Steuerelements gehört.
Invoke(Delegate, Object[])	Führt den angegebenen Delegaten im Thread aus, der das zugrunde liegende Fensterhandle des Steuerelements besitzt, mit der angegebenen Liste der Argumente.
Invoke<T>(Func<T>)	Führt den angegebenen Delegaten im Thread aus, der dem zugrunde liegenden Fensterhandle des Steuerelements gehört.

Invoke(Action)

Führt den angegebenen Delegaten im Thread aus, der dem zugrunde liegenden Fensterhandle des Steuerelements gehört.

public:
 void Invoke(Action ^ method);

public void Invoke (Action method);

member this.Invoke : Action -> unit

Public Sub Invoke (method As Action)

Parameter

method: Action

Ein Delegat, der eine Methode enthält, die im Threadkontext des Steuerelements aufgerufen werden soll.

Gilt für:

Invoke(Delegate)

Führt den angegebenen Delegaten im Thread aus, der dem zugrunde liegenden Fensterhandle des Steuerelements gehört.

public:
 System::Object ^ Invoke(Delegate ^ method);

public object Invoke (Delegate method);

member this.Invoke : Delegate -> obj

Public Function Invoke (method As Delegate) As Object

Parameter

method: Delegate

Ein Delegat, der eine Methode enthält, die im Threadkontext des Steuerelements aufgerufen werden soll.

Gibt zurück

Object

Der Rückgabewert des aufgerufenen Delegaten oder null, wenn der Delegat keinen Rückgabewert aufweist.

Beispiele

Das folgende Codebeispiel zeigt Steuerelemente, die einen Delegaten enthalten. Der Delegat kapselt eine Methode, die dem Listenfeld Elemente hinzufügt, und diese Methode wird im Thread ausgeführt, der den zugrunde liegenden Handle des Formulars besitzt. Wenn der Benutzer auf die Schaltfläche klickt, führt Invoke den Delegaten aus.

/*
The following example demonstrates the 'Invoke(Delegate*)' method of 'Control class.
A 'ListBox' and a 'Button' control are added to a form, containing a delegate
which encapsulates a method that adds items to the listbox. This function is executed
on the thread that owns the underlying handle of the form. When user clicks on button
the above delegate is executed using 'Invoke' method.
*/

#using <System.dll>
#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
using namespace System::Threading;

public ref class MyFormControl: public Form
{
public:
   delegate void AddListItem();
   AddListItem^ myDelegate;

private:
   Button^ myButton;
   Thread^ myThread;
   ListBox^ myListBox;

public:
   MyFormControl();
   void AddListItemMethod()
   {
      String^ myItem;
      for ( int i = 1; i < 6; i++ )
      {
         myItem = "MyListItem {0}",i;
         myListBox->Items->Add( myItem );
         myListBox->Update();
         Thread::Sleep( 300 );
      }
   }

private:
   void Button_Click( Object^ /*sender*/, EventArgs^ /*e*/ )
   {
      myThread = gcnew Thread( gcnew ThreadStart( this, &MyFormControl::ThreadFunction ) );
      myThread->Start();
   }

   void ThreadFunction();
};


// The following code assumes a 'ListBox' and a 'Button' control are added to a form,
// containing a delegate which encapsulates a method that adds items to the listbox.
public ref class MyThreadClass
{
private:
   MyFormControl^ myFormControl1;

public:
   MyThreadClass( MyFormControl^ myForm )
   {
      myFormControl1 = myForm;
   }

   void Run()
   {
      // Execute the specified delegate on the thread that owns
      // 'myFormControl1' control's underlying window handle.
      myFormControl1->Invoke( myFormControl1->myDelegate );
   }
};


MyFormControl::MyFormControl()
{
   myButton = gcnew Button;
   myListBox = gcnew ListBox;
   myButton->Location = Point( 72, 160 );
   myButton->Size = System::Drawing::Size( 152, 32 );
   myButton->TabIndex = 1;
   myButton->Text = "Add items in list box";
   myButton->Click += gcnew EventHandler( this, &MyFormControl::Button_Click );
   myListBox->Location = Point( 48, 32 );
   myListBox->Name = "myListBox";
   myListBox->Size = System::Drawing::Size( 200, 95 );
   myListBox->TabIndex = 2;
   ClientSize = System::Drawing::Size( 292, 273 );
   array<Control^>^ temp0 = {myListBox,myButton};
   Controls->AddRange( temp0 );
   Text = " 'Control_Invoke' example";
   myDelegate = gcnew AddListItem( this, &MyFormControl::AddListItemMethod );
}

void MyFormControl::ThreadFunction()
{
   MyThreadClass^ myThreadClassObject = gcnew MyThreadClass( this );
   myThreadClassObject->Run();
}

int main()
{
   MyFormControl^ myForm = gcnew MyFormControl;
   myForm->ShowDialog();
}

/*
The following example demonstrates the 'Invoke(Delegate)' method of 'Control class.
A 'ListBox' and a 'Button' control are added to a form, containing a delegate
which encapsulates a method that adds items to the listbox. This function is executed
on the thread that owns the underlying handle of the form. When user clicks on button
the above delegate is executed using 'Invoke' method.


*/

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;

   public class MyFormControl : Form
   {
      public delegate void AddListItem();
      public AddListItem myDelegate;
      private Button myButton;
      private Thread myThread;
      private ListBox myListBox;
      public MyFormControl()
      {
         myButton = new Button();
         myListBox = new ListBox();
         myButton.Location = new Point(72, 160);
         myButton.Size = new Size(152, 32);
         myButton.TabIndex = 1;
         myButton.Text = "Add items in list box";
         myButton.Click += new EventHandler(Button_Click);
         myListBox.Location = new Point(48, 32);
         myListBox.Name = "myListBox";
         myListBox.Size = new Size(200, 95);
         myListBox.TabIndex = 2;
         ClientSize = new Size(292, 273);
         Controls.AddRange(new Control[] {myListBox,myButton});
         Text = " 'Control_Invoke' example";
         myDelegate = new AddListItem(AddListItemMethod);
      }
      static void Main()
      {
         MyFormControl myForm = new MyFormControl();
         myForm.ShowDialog();
      }
      public void AddListItemMethod()
      {
         String myItem;
         for(int i=1;i<6;i++)
         {
            myItem = "MyListItem" + i.ToString();
            myListBox.Items.Add(myItem);
            myListBox.Update();
            Thread.Sleep(300);
         }
      }
      private void Button_Click(object sender, EventArgs e)
      {
         myThread = new Thread(new ThreadStart(ThreadFunction));
         myThread.Start();
      }
      private void ThreadFunction()
      {
         MyThreadClass myThreadClassObject  = new MyThreadClass(this);
         myThreadClassObject.Run();
      }
   }

// The following code assumes a 'ListBox' and a 'Button' control are added to a form, 
// containing a delegate which encapsulates a method that adds items to the listbox.

   public class MyThreadClass
   {
      MyFormControl myFormControl1;
      public MyThreadClass(MyFormControl myForm)
      {
         myFormControl1 = myForm;
      }

      public void Run()
      {
         // Execute the specified delegate on the thread that owns
         // 'myFormControl1' control's underlying window handle.
         myFormControl1.Invoke(myFormControl1.myDelegate);
      }
   }

' The following example demonstrates the 'Invoke(Delegate)' method of 'Control class.
' A 'ListBox' and a 'Button' control are added to a form, containing a delegate
' which encapsulates a method that adds items to the listbox. This function is executed
' on the thread that owns the underlying handle of the form. When user clicks on button
' the above delegate is executed using 'Invoke' method.

Imports System.Drawing
Imports System.Windows.Forms
Imports System.Threading

Public Class MyFormControl
   Inherits Form

   Delegate Sub AddListItem()
   Public myDelegate As AddListItem
   Private myButton As Button
   Private myThread As Thread
   Private myListBox As ListBox

   Public Sub New()
      myButton = New Button()
      myListBox = New ListBox()
      myButton.Location = New Point(72, 160)
      myButton.Size = New Size(152, 32)
      myButton.TabIndex = 1
      myButton.Text = "Add items in list box"
      AddHandler myButton.Click, AddressOf Button_Click
      myListBox.Location = New Point(48, 32)
      myListBox.Name = "myListBox"
      myListBox.Size = New Size(200, 95)
      myListBox.TabIndex = 2
      ClientSize = New Size(292, 273)
      Controls.AddRange(New Control() {myListBox, myButton})
      Text = " 'Control_Invoke' example"
      myDelegate = New AddListItem(AddressOf AddListItemMethod)
   End Sub

   Shared Sub Main()
      Dim myForm As New MyFormControl()
      myForm.ShowDialog()
   End Sub

   Public Sub AddListItemMethod()
      Dim myItem As String
      Dim i As Integer
      For i = 1 To 5
         myItem = "MyListItem" + i.ToString()
         myListBox.Items.Add(myItem)
         myListBox.Update()
         Thread.Sleep(300)
      Next i
   End Sub

   Private Sub Button_Click(sender As Object, e As EventArgs)
      myThread = New Thread(New ThreadStart(AddressOf ThreadFunction))
      myThread.Start()
   End Sub

   Private Sub ThreadFunction()
      Dim myThreadClassObject As New MyThreadClass(Me)
      myThreadClassObject.Run()
   End Sub
End Class


' The following code assumes a 'ListBox' and a 'Button' control are added to a form, 
' containing a delegate which encapsulates a method that adds items to the listbox.
Public Class MyThreadClass
   Private myFormControl1 As MyFormControl

   Public Sub New(myForm As MyFormControl)
      myFormControl1 = myForm
   End Sub

   Public Sub Run()
      ' Execute the specified delegate on the thread that owns
      ' 'myFormControl1' control's underlying window handle.
      myFormControl1.Invoke(myFormControl1.myDelegate)
   End Sub

End Class

Hinweise

Stellvertretungen ähneln Funktionszeigern in C- oder C++-Sprachen. Delegaten kapseln einen Verweis auf eine Methode innerhalb eines Delegatenobjekts. Das Delegatobjekt kann dann an Code übergeben werden, der die referenzierte Methode aufruft, und die aufgerufene Methode kann zur Kompilierungszeit unbekannt sein. Im Gegensatz zu Funktionszeigern in C oder C++ sind Stellvertretungen objektorientiert, typsicher und sicherer.

Die Invoke-Methode durchsucht die übergeordnete Kette des Steuerelements, bis ein Steuerelement oder Formular mit einem Fensterziehpunkt gefunden wird, wenn der zugrunde liegende Fensterziehpunkt des aktuellen Steuerelements noch nicht vorhanden ist. Wenn kein geeigneter Handle gefunden werden kann, löst die Invoke-Methode eine Ausnahme aus. Ausnahmen, die während des Anrufs ausgelöst werden, werden an den Anrufer weitergegeben.

Anmerkung

Neben der InvokeRequired-Eigenschaft gibt es vier Methoden für ein Steuerelement, das threadsicher ist: Invoke, BeginInvoke, EndInvokeund CreateGraphics, wenn das Handle für das Steuerelement bereits erstellt wurde. Das Aufrufen von CreateGraphics, bevor das Handle des Steuerelements in einem Hintergrundthread erstellt wurde, kann zu unzulässigen Threadaufrufen führen. Für alle anderen Methodenaufrufe sollten Sie eine der Aufrufmethoden verwenden, um den Aufruf an den Thread des Steuerelements zu marshallen.

Der Delegat kann eine Instanz von EventHandlersein, in diesem Fall enthält der Senderparameter dieses Steuerelement, und der Ereignisparameter enthält EventArgs.Empty. Die Stellvertretung kann auch eine Instanz von MethodInvokeroder eine andere Stellvertretung sein, die eine Liste mit ungültigen Parametern akzeptiert. Ein Anruf an eine EventHandler oder MethodInvoker Stellvertretung ist schneller als ein Anruf an einen anderen Stellvertretertyp.

Anmerkung

Eine Ausnahme kann ausgelöst werden, wenn der Thread, der die Nachricht verarbeiten soll, nicht mehr aktiv ist.

Weitere Informationen

Gilt für:

Invoke(Delegate, Object[])

Führt den angegebenen Delegaten im Thread aus, der das zugrunde liegende Fensterhandle des Steuerelements besitzt, mit der angegebenen Liste der Argumente.

public:
 virtual System::Object ^ Invoke(Delegate ^ method, cli::array <System::Object ^> ^ args);

public:
 virtual System::Object ^ Invoke(Delegate ^ method, ... cli::array <System::Object ^> ^ args);

public object Invoke (Delegate method, object[] args);

public object Invoke (Delegate method, params object[] args);

public object Invoke (Delegate method, params object?[]? args);

abstract member Invoke : Delegate * obj[] -> obj
override this.Invoke : Delegate * obj[] -> obj

Public Function Invoke (method As Delegate, args As Object()) As Object

Public Function Invoke (method As Delegate, ParamArray args As Object()) As Object

Parameter

method: Delegate

Ein Delegat an eine Methode, die Parameter der gleichen Zahl und desselben Typs verwendet, die im args-Parameter enthalten sind.

args: Object[]

Ein Array von Objekten, die als Argumente an die angegebene Methode übergeben werden sollen. Dieser Parameter kann null werden, wenn die Methode keine Argumente verwendet.

Gibt zurück

Object

Ein Object, das den Rückgabewert des aufgerufenen Delegaten enthält, oder null, wenn der Delegat keinen Rückgabewert aufweist.

Implementiert

Invoke(Delegate, Object[])

Beispiele

Das folgende Codebeispiel zeigt Steuerelemente, die einen Delegaten enthalten. Der Delegat kapselt eine Methode, die dem Listenfeld Elemente hinzufügt, und diese Methode wird im Thread ausgeführt, der das zugrunde liegende Handle des Formulars unter Verwendung der angegebenen Argumente besitzt. Wenn der Benutzer auf die Schaltfläche klickt, führt Invoke den Delegaten aus.

using namespace System;
using namespace System::Drawing;
using namespace System::ComponentModel;
using namespace System::Windows::Forms;
using namespace System::Threading;
ref class MyFormControl: public Form
{
public:
   delegate void AddListItem( String^ myString );
   AddListItem^ myDelegate;

private:
   Button^ myButton;
   Thread^ myThread;
   ListBox^ myListBox;

public:
   MyFormControl();
   void AddListItemMethod( String^ myString );

private:
   void Button_Click( Object^ sender, EventArgs^ e );
   void ThreadFunction();
};

ref class MyThreadClass
{
private:
   MyFormControl^ myFormControl1;

public:
   MyThreadClass( MyFormControl^ myForm )
   {
      myFormControl1 = myForm;
   }

   String^ myString;
   void Run()
   {
      for ( int i = 1; i <= 5; i++ )
      {
         myString = String::Concat( "Step number ", i, " executed" );
         Thread::Sleep( 400 );
         
         // Execute the specified delegate on the thread that owns
         // 'myFormControl1' control's underlying window handle with
         // the specified list of arguments.
         array<Object^>^myStringArray = {myString};
         myFormControl1->Invoke( myFormControl1->myDelegate, myStringArray );

      }
   }

};

MyFormControl::MyFormControl()
{
   myButton = gcnew Button;
   myListBox = gcnew ListBox;
   myButton->Location = Point(72,160);
   myButton->Size = System::Drawing::Size( 152, 32 );
   myButton->TabIndex = 1;
   myButton->Text = "Add items in list box";
   myButton->Click += gcnew EventHandler( this, &MyFormControl::Button_Click );
   myListBox->Location = Point(48,32);
   myListBox->Name = "myListBox";
   myListBox->Size = System::Drawing::Size( 200, 95 );
   myListBox->TabIndex = 2;
   ClientSize = System::Drawing::Size( 292, 273 );
   array<Control^>^formControls = {myListBox,myButton};
   Controls->AddRange( formControls );
   Text = " 'Control_Invoke' example ";
   myDelegate = gcnew AddListItem( this, &MyFormControl::AddListItemMethod );
}

void MyFormControl::AddListItemMethod( String^ myString )
{
   myListBox->Items->Add( myString );
}

void MyFormControl::Button_Click( Object^ /*sender*/, EventArgs^ /*e*/ )
{
   myThread = gcnew Thread( gcnew ThreadStart( this, &MyFormControl::ThreadFunction ) );
   myThread->Start();
}

void MyFormControl::ThreadFunction()
{
   MyThreadClass^ myThreadClassObject = gcnew MyThreadClass( this );
   myThreadClassObject->Run();
}

int main()
{
   MyFormControl^ myForm = gcnew MyFormControl;
   myForm->ShowDialog();
}

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;

   public class MyFormControl : Form
   {
      public delegate void AddListItem(String myString);
      public AddListItem myDelegate;
      private Button myButton;
      private Thread myThread;
      private ListBox myListBox;
      public MyFormControl()
      {
         myButton = new Button();
         myListBox = new ListBox();
         myButton.Location = new Point(72, 160);
         myButton.Size = new Size(152, 32);
         myButton.TabIndex = 1;
         myButton.Text = "Add items in list box";
         myButton.Click += new EventHandler(Button_Click);
         myListBox.Location = new Point(48, 32);
         myListBox.Name = "myListBox";
         myListBox.Size = new Size(200, 95);
         myListBox.TabIndex = 2;
         ClientSize = new Size(292, 273);
         Controls.AddRange(new Control[] {myListBox,myButton});
         Text = " 'Control_Invoke' example ";
         myDelegate = new AddListItem(AddListItemMethod);
      }
      static void Main()
      {
         MyFormControl myForm = new MyFormControl();
         myForm.ShowDialog();
      }
      public void AddListItemMethod(String myString)
      {
            myListBox.Items.Add(myString);
      }
      private void Button_Click(object sender, EventArgs e)
      {
         myThread = new Thread(new ThreadStart(ThreadFunction));
         myThread.Start();
      }
      private void ThreadFunction()
      {
         MyThreadClass myThreadClassObject  = new MyThreadClass(this);
         myThreadClassObject.Run();
      }
   }
   public class MyThreadClass
   {
      MyFormControl myFormControl1;
      public MyThreadClass(MyFormControl myForm)
      {
         myFormControl1 = myForm;
      }
      String myString;

      public void Run()
      {

         for (int i = 1; i <= 5; i++)
         {
            myString = "Step number " + i.ToString() + " executed";
            Thread.Sleep(400);
            // Execute the specified delegate on the thread that owns
            // 'myFormControl1' control's underlying window handle with
            // the specified list of arguments.
            myFormControl1.Invoke(myFormControl1.myDelegate,
                                   new Object[] {myString});
         }
      }
   }

Imports System.Drawing
Imports System.Windows.Forms
Imports System.Threading

Public Class MyFormControl
   Inherits Form

   Delegate Sub AddListItem(myString As String)
   Public myDelegate As AddListItem
   Private myButton As Button
   Private myThread As Thread
   Private myListBox As ListBox

   Public Sub New()
      myButton = New Button()
      myListBox = New ListBox()
      myButton.Location = New Point(72, 160)
      myButton.Size = New Size(152, 32)
      myButton.TabIndex = 1
      myButton.Text = "Add items in list box"
      AddHandler myButton.Click, AddressOf Button_Click
      myListBox.Location = New Point(48, 32)
      myListBox.Name = "myListBox"
      myListBox.Size = New Size(200, 95)
      myListBox.TabIndex = 2
      ClientSize = New Size(292, 273)
      Controls.AddRange(New Control() {myListBox, myButton})
      Text = " 'Control_Invoke' example "
      myDelegate = New AddListItem(AddressOf AddListItemMethod)
   End Sub

   Shared Sub Main()
      Dim myForm As New MyFormControl()
      myForm.ShowDialog()
   End Sub

   Public Sub AddListItemMethod(myString As String)
      myListBox.Items.Add(myString)
   End Sub

   Private Sub Button_Click(sender As Object, e As EventArgs)
      myThread = New Thread(New ThreadStart(AddressOf ThreadFunction))
      myThread.Start()
   End Sub

   Private Sub ThreadFunction()
      Dim myThreadClassObject As New MyThreadClass(Me)
      myThreadClassObject.Run()
   End Sub
End Class

Public Class MyThreadClass
   Private myFormControl1 As MyFormControl

   Public Sub New(myForm As MyFormControl)
      myFormControl1 = myForm
   End Sub
   Private myString As String

   Public Sub Run()

      Dim i As Integer
      For i = 1 To 5
         myString = "Step number " + i.ToString() + " executed"
         Thread.Sleep(400)
         ' Execute the specified delegate on the thread that owns
         ' 'myFormControl1' control's underlying window handle with
         ' the specified list of arguments.
         myFormControl1.Invoke(myFormControl1.myDelegate, New Object() {myString})
      Next i

   End Sub
End Class

Hinweise

Wenn der Steuerpunkt des Steuerelements noch nicht vorhanden ist, durchsucht diese Methode die übergeordnete Kette des Steuerelements, bis es ein Steuerelement oder Formular findet, das über ein Fensterhandle verfügt. Wenn kein geeignetes Handle gefunden werden kann, löst diese Methode eine Ausnahme aus. Ausnahmen, die während des Anrufs ausgelöst werden, werden an den Anrufer weitergegeben.

Anmerkung

Der Delegat kann eine Instanz von EventHandlersein, in diesem Fall hängen die Parameter vom args Wert ab:

Wenn keine Parameter übergeben werden, enthält der Senderparameter dieses Steuerelement, und der Ereignisparameter enthält EventArgs.Empty.
Wenn ein einzelner Parameter übergeben wird, enthält der Senderparameter das erste Args-Element, und der Ereignisparameter enthält EventArgs.Empty.
Wenn mehrere Parameter übergeben werden, enthält der Senderparameter das erste Element aus args, und der parameter EventArgs enthält das zweite Element.

Ein Anruf an eine EventHandler oder MethodInvoker Stellvertretung ist schneller als ein Anruf an einen anderen Stellvertretertyp.

Anmerkung

Eine Ausnahme kann ausgelöst werden, wenn der Thread, der die Nachricht verarbeiten soll, nicht mehr aktiv ist.

Weitere Informationen

Gilt für:

Invoke<T>(Func<T>)

Führt den angegebenen Delegaten im Thread aus, der dem zugrunde liegenden Fensterhandle des Steuerelements gehört.

public:
generic <typename T>
 T Invoke(Func<T> ^ method);

public T Invoke<T> (Func<T> method);

member this.Invoke : Func<'T> -> 'T

Public Function Invoke(Of T) (method As Func(Of T)) As T

Typparameter

T

Der Rückgabetyp des method.

Parameter

method: Func<T>

Eine Funktion, die im Threadkontext des Steuerelements aufgerufen werden soll.

Gibt zurück

Der Rückgabewert der aufgerufenen Funktion.

Gilt für:

Freigeben über

Control.Invoke Methode

Definition

Überlädt

Invoke(Action)

Parameter

Gilt für:

Invoke(Delegate)

Parameter

Gibt zurück

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Invoke(Delegate, Object[])

Parameter

Gibt zurück

Implementiert

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Invoke<T>(Func<T>)

Typparameter

Parameter

Gibt zurück

Gilt für:

Zusätzliche Ressourcen