Control.Invoke Control.Invoke Control.Invoke Control.Invoke Method

Definition

Führt einen Delegaten in dem Thread aus, der das dem Steuerelement zugrunde liegende Fensterhandle besitzt.Executes a delegate on the thread that owns the control's underlying window handle.

Überlädt

Invoke(Delegate) Invoke(Delegate) Invoke(Delegate) Invoke(Delegate)

Führt den angegebenen Delegaten für den Thread aus, der das dem Steuerelement zugrunde liegende Fensterhandle besitzt.Executes the specified delegate on the thread that owns the control's underlying window handle.

Invoke(Delegate, Object[]) Invoke(Delegate, Object[]) Invoke(Delegate, Object[]) Invoke(Delegate, Object[])

Führt mit der angegebenen Argumentliste den angegebenen Delegaten für den Thread aus, der das dem Steuerelement zugrunde liegende Fensterhandle besitzt.Executes the specified delegate, on the thread that owns the control's underlying window handle, with the specified list of arguments.

Invoke(Delegate) Invoke(Delegate) Invoke(Delegate) Invoke(Delegate)

Führt den angegebenen Delegaten für den Thread aus, der das dem Steuerelement zugrunde liegende Fensterhandle besitzt.Executes the specified delegate on the thread that owns the control's underlying window handle.

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 Delegate Delegate Delegate

Ein Delegat, der eine aufzurufende Methode im Threadkontext des Steuerelements enthält.A delegate that contains a method to be called in the control's thread context.

Gibt zurück

Der Rückgabewert des aufgerufenen Delegaten bzw. null, wenn der Delegat keinen Wert zurückgibt.The return value from the delegate being invoked, or null if the delegate has no return value.

Beispiele

Das folgende Codebeispiel zeigt Steuerelemente, die einen Delegaten enthalten.The following code example shows controls that contain a delegate. Der-Delegat kapselt eine Methode, die dem Listenfeld Elemente hinzufügt, und diese Methode wird auf dem Thread ausgeführt, der das zugrunde liegende Handle des Formulars besitzt.The delegate encapsulates a method that adds items to the list box, and this method is executed on the thread that owns the underlying handle of the form. Wenn der Benutzer auf die Schaltfläche klickt Invoke , führt den Delegaten aus.When the user clicks on the button, Invoke runs the delegate.

/*
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
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 'New

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

   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 'AddListItemMethod

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

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


' 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 'New

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

End Class 'MyThreadClass

Hinweise

Delegaten ähneln Funktions Zeigern in C oder C++ Sprachen.Delegates are similar to function pointers in C or C++ languages. Delegaten Kapseln einen Verweis auf eine Methode innerhalb eines Delegatobjekts.Delegates encapsulate a reference to a method inside a delegate object. Das Delegatobjekt kann dann an den Code weitergeleitet werden, der die referenzierte Methode aufruft, und die aufzurufende Methode kann zur Kompilierzeit nicht bekannt sein.The delegate object can then be passed to code that calls the referenced method, and the method to be invoked can be unknown at compile time. Im Gegensatz zu Funktions Zeigern C++in C oder sind Delegaten objektorientiert, typsicher und sicherer.Unlike function pointers in C or C++, delegates are object-oriented, type-safe, and more secure.

Die Invoke -Methode durchsucht die übergeordnete Kette des Steuer Elements, bis ein Steuerelement oder ein Formular mit einem Fenster Handle gefunden wird, wenn das zugrunde liegende Fenster Handle des aktuellen Steuer Elements noch nicht vorhanden ist.The Invoke method searches up the control's parent chain until it finds a control or form that has a window handle if the current control's underlying window handle does not exist yet. Wenn kein entsprechendes Handle gefunden werden kann, löst Invoke die Methode eine Ausnahme aus.If no appropriate handle can be found, the Invoke method will throw an exception. Ausnahmen, die während des Aufrufens ausgelöst werden, werden an den Aufrufer zurückgegeben.Exceptions that are raised during the call will be propagated back to the caller.

Hinweis

Zusätzlich zur InvokeRequired -Eigenschaft gibt es vier Methoden auf einem-Steuerelement, die Thread sicher sind Invoke: BeginInvoke, EndInvoke, und CreateGraphics , wenn das Handle für das Steuerelement bereits erstellt wurde.In addition to the InvokeRequired property, there are four methods on a control that are thread safe: Invoke, BeginInvoke, EndInvoke, and CreateGraphics if the handle for the control has already been created. Wenn CreateGraphics aufgerufen wird, bevor das Handle des Steuer Elements in einem Hintergrund Thread erstellt wurde, kann dies zu ungültigen Thread übergreifenden aufrufen führen.Calling CreateGraphics before the control's handle has been created on a background thread can cause illegal cross thread calls. Für alle anderen Methodenaufrufe sollten Sie eine der Aufruf Methoden verwenden, um den Aufruf an den Thread des Steuer Elements zu Mars Hallen.For all other method calls, you should use one of the invoke methods to marshal the call to the control's thread.

Der Delegat kann eine Instanz von EventHandlersein. in diesem Fall enthält der Sender-Parameter dieses Steuerelement, und der Ereignis Parameter EventArgs.Emptyenthält.The delegate can be an instance of EventHandler, in which case the sender parameter will contain this control, and the event parameter will contain EventArgs.Empty. Der Delegat kann auch eine Instanz von MethodInvokeroder ein beliebiger anderer Delegat sein, der eine void-Parameterliste annimmt.The delegate can also be an instance of MethodInvoker, or any other delegate that takes a void parameter list. Ein Aufruf EventHandler eines-oder MethodInvoker -Delegaten ist schneller als ein Aufruf eines anderen Delegattyps.A call to an EventHandler or MethodInvoker delegate will be faster than a call to another type of delegate.

Hinweis

Eine Ausnahme kann ausgelöst werden, wenn der Thread, der die Nachricht verarbeiten soll, nicht mehr aktiv ist.An exception might be thrown if the thread that should process the message is no longer active.

Siehe auch

Invoke(Delegate, Object[]) Invoke(Delegate, Object[]) Invoke(Delegate, Object[]) Invoke(Delegate, Object[])

Führt mit der angegebenen Argumentliste den angegebenen Delegaten für den Thread aus, der das dem Steuerelement zugrunde liegende Fensterhandle besitzt.Executes the specified delegate, on the thread that owns the control's underlying window handle, with the specified list of arguments.

public:
 virtual System::Object ^ Invoke(Delegate ^ method, ... cli::array <System::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, ParamArray args As Object()) As Object

Parameter

method
Delegate Delegate Delegate Delegate

Ein Delegat einer Methode, der Parameter derselben Anzahl und desselben Typs der im args-Parameter enthaltenen Parameter annimmt.A delegate to a method that takes parameters of the same number and type that are contained in the args parameter.

args
Object[]

Ein Array von Objekten, die als Argumente an die angegebene Methode übergeben werden sollen.An array of objects to pass as arguments to the specified method. Dieser Parameter kann null sein, wenn die Methode keine Argumente annimmt.This parameter can be null if the method takes no arguments.

Gibt zurück

Ein Object, das den Rückgabewert des aufgerufenen Delegaten enthält, oder null, wenn der Delegat keinen Wert zurückgibt.An Object that contains the return value from the delegate being invoked, or null if the delegate has no return value.

Implementiert

Beispiele

Das folgende Codebeispiel zeigt Steuerelemente, die einen Delegaten enthalten.The following code example shows controls that contain a delegate. Der-Delegat kapselt eine Methode, die dem Listenfeld Elemente hinzufügt, und diese Methode wird auf dem Thread ausgeführt, der das zugrunde liegende Handle des Formulars besitzt, wobei die angegebenen Argumente verwendet werden.The delegate encapsulates a method that adds items to the list box, and this method is executed on the thread that owns the underlying handle of the form, using the specified arguments. Wenn der Benutzer auf die Schaltfläche klickt Invoke , führt den Delegaten aus.When the user clicks on the button, Invoke runs the delegate.

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
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 'New

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

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

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

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

Public Class MyThreadClass
   Private myFormControl1 As MyFormControl

   Public Sub New(myForm As MyFormControl)
      myFormControl1 = myForm
   End Sub 'New
   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 'Run
End Class 'MyThreadClass

Hinweise

Delegaten ähneln Funktions Zeigern in C oder C++ Sprachen.Delegates are similar to function pointers in C or C++ languages. Delegaten Kapseln einen Verweis auf eine Methode innerhalb eines Delegatobjekts.Delegates encapsulate a reference to a method inside a delegate object. Das Delegatobjekt kann dann an den Code weitergeleitet werden, der die referenzierte Methode aufruft, und die aufzurufende Methode kann zur Kompilierzeit nicht bekannt sein.The delegate object can then be passed to code that calls the referenced method, and the method to be invoked can be unknown at compile time. Im Gegensatz zu Funktions Zeigern C++in C oder sind Delegaten objektorientiert, typsicher und sicherer.Unlike function pointers in C or C++, delegates are object-oriented, type-safe, and more secure.

Wenn das Handle des Steuer Elements noch nicht vorhanden ist, durchsucht diese Methode die übergeordnete Kette des Steuer Elements, bis ein Steuerelement oder ein Formular gefunden wird, das über ein Fenster Handle verfügt.If the control's handle does not exist yet, this method searches up the control's parent chain until it finds a control or form that does have a window handle. Wenn kein entsprechendes Handle gefunden werden kann, löst diese Methode eine Ausnahme aus.If no appropriate handle can be found, this method throws an exception. Ausnahmen, die während des Aufrufens ausgelöst werden, werden an den Aufrufer zurückgegeben.Exceptions that are raised during the call will be propagated back to the caller.

Hinweis

Zusätzlich zur InvokeRequired -Eigenschaft gibt es vier Methoden auf einem-Steuerelement, die Thread sicher sind Invoke: BeginInvoke, EndInvoke, und CreateGraphics , wenn das Handle für das Steuerelement bereits erstellt wurde.In addition to the InvokeRequired property, there are four methods on a control that are thread safe: Invoke, BeginInvoke, EndInvoke, and CreateGraphics if the handle for the control has already been created. Wenn CreateGraphics aufgerufen wird, bevor das Handle des Steuer Elements in einem Hintergrund Thread erstellt wurde, kann dies zu ungültigen Thread übergreifenden aufrufen führen.Calling CreateGraphics before the control's handle has been created on a background thread can cause illegal cross thread calls. Für alle anderen Methodenaufrufe sollten Sie eine der Aufruf Methoden verwenden, um den Aufruf an den Thread des Steuer Elements zu Mars Hallen.For all other method calls, you should use one of the invoke methods to marshal the call to the control's thread.

Der Delegat kann eine Instanz von EventHandlersein. in diesem Fall enthält der Sender-Parameter dieses Steuerelement, und der Ereignis Parameter EventArgs.Emptyenthält.The delegate can be an instance of EventHandler, in which case the sender parameter will contain this control, and the event parameter will contain EventArgs.Empty. Der Delegat kann auch eine Instanz von MethodInvokeroder ein beliebiger anderer Delegat sein, der eine void-Parameterliste annimmt.The delegate can also be an instance of MethodInvoker, or any other delegate that takes a void parameter list. Ein Aufruf EventHandler eines-oder MethodInvoker -Delegaten ist schneller als ein Aufruf eines anderen Delegattyps.A call to an EventHandler or MethodInvoker delegate will be faster than a call to another type of delegate.

Hinweis

Eine Ausnahme kann ausgelöst werden, wenn der Thread, der die Nachricht verarbeiten soll, nicht mehr aktiv ist.An exception might be thrown if the thread that should process the message is no longer active.

Siehe auch

Gilt für: