Executes the specified delegate, on the thread that owns the control's underlying window handle, with the specified list of arguments.
Namespace:
System.Windows.Forms
Assembly:
System.Windows.Forms (in System.Windows.Forms.dll)
Visual Basic (Declaration)
Public Function Invoke ( _
method As Delegate, _
ParamArray args As Object() _
) As Object
Dim instance As Control
Dim method As [Delegate]
Dim args As Object()
Dim returnValue As Object
returnValue = instance.Invoke(method, _
args)
public Object Invoke(
Delegate method,
params Object[] args
)
public:
virtual Object^ Invoke(
Delegate^ method,
... array<Object^>^ args
) sealed
public final function Invoke(
method : Delegate,
... args : Object[]
) : Object
Parameters
- method
- Type: System..::.Delegate
A delegate to a method that takes parameters of the same number and type that are contained in the args parameter.
- args
- Type: array<System..::.Object>[]()[]
An array of objects to pass as arguments to the specified method. This parameter can be nullNothingnullptra null reference (Nothing in Visual Basic) if the method takes no arguments.
Return Value
Type:
System..::.ObjectAn Object that contains the return value from the delegate being invoked, or nullNothingnullptra null reference (Nothing in Visual Basic) if the delegate has no return value.
Implements
ISynchronizeInvoke..::.Invoke(Delegate, array<Object>[]()[])
Delegates are similar to function pointers in C or C++ languages. Delegates encapsulate a reference to a method inside a delegate object. 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. Unlike function pointers in C or C++, delegates are object-oriented, type-safe, and more secure.
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. If no appropriate handle can be found, this method throws an exception. Exceptions that are raised during the call will be propagated back to the caller.
Note: |
|---|
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. Calling CreateGraphics before the control's handle has been created on a background thread can cause illegal cross thread calls. For all other method calls, you should use one of the invoke methods to marshal the call to the control's thread. |
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. The delegate can also be an instance of MethodInvoker, or any other delegate that takes a void parameter list. A call to an EventHandler or MethodInvoker delegate will be faster than a call to another type of delegate.
Note: |
|---|
An exception might be thrown if the thread that should process the message is no longer active. |
Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows CE Platform Note:
In .NET Compact Framework applications, the delegate must be an instance of EventHandler. For an example, see Delegates Sample.
The following code example shows controls that contain a delegate. 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. When the user clicks on the button, Invoke runs the delegate.
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
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});
}
}
}
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();
}
Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC
The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.
.NET Framework
Supported in: 3.5, 3.0, 2.0, 1.1, 1.0
.NET Compact Framework
Supported in: 3.5, 2.0
Reference
Other Resources