Methods that affect a Windows Forms control can be executed only on the thread that created the control. .NET does not permit directly manipulating controls across threads. The Visual Studio compiler under .NET 2.0 will mark these attempts as errors. .NET 1.1 will allow them, but these will often result in unexpected behavior like incorrectly-painted controls.

Limit Cross-Thread Calls

Marshalling method calls from one thread and sending them across thread boundaries to another thread is expensive in terms of system resources. At best, the performance of your application may suffer. At worst, conditions could occur that cause a deadlock in your application and freeze execution. Hence, you should limit repeated calls to controls on other threads.

However, there are times when it’s necessary to manipulate controls across threads. For example, you might disable a button or update a form in response to action taken by a separate thread.

Proper Method

The .NET Framework provides methods that are safe to call from any thread for invoking methods that manipulate controls created by other threads.

To access a .NET control from another thread, you must use the Invoke method as follows:

  • Before accessing a .NET control, check the control’s InvokeRequired property.
  • If true, call the control’s Invoke property with the proper arguments. This invokes your code in the same thread as the control.
  • If false, you can access the control’s properties directly.

Sample Code

The following code demonstrates how you can access a .NET control across threads. For this example, assume you have defined a Form that includes a Label control:

public partial class MyForm : Form
    private Label Label_Status;

To set the label’s text across threads, add the following method to the MyForm class:

public void SetStatus( string text )
    if (this.Label_Status.InvokeRequired)
            new MethodInvoker(
            delegate() { SetStatus( text ); } ) );
        this.Label_Status.Text = text;

Anonymous Delegates

The key to this example is the use of anonymous delegates and the MethodInvoker method. The anonymous delegate eliminates the need to formally define a separate delegate. MethodInvoker provides a simple delegate to invoke a method with a void parameter list. This delegate can be used when making calls to a control’s Invoke method, or when you need a simple delegate but do not want to define one yourself.

Share and Enjoy:
  • Digg
  • Twitter
  • Facebook
  • Reddit
  • StumbleUpon
  • LinkedIn
  • Google Bookmarks
  • Slashdot