The key to multi-threaded Windows Forms UI interaction

• Download source files - 11 Kb
• Download demo project - 4 Kb

Introduction

I don't intend for this article to teach multi-threaded programming in .NET, I do want to point out some important things when dealing with multi-threaded programs in a Windows Forms environment.  This article will be code light, however I have provided a full sample illustrating how to employ the practices required of a Multi-Threaded Windows Forms application.

What not to do

First and foremost (and the reason I'm writing this article) is that you absolutely, positively, cannot interact with UI elements from a thread that did not create them.  You may get away with it in some cases, but it will fail at some point and then heads will roll because you will have a lot of code to change.  Now you may ask how should you interact with the UI from another thread. 

What you should do

Luckily the designers for Windows Forms realized the plight that may be caused without being able to interact with the UI from another thread.  So they add the Invoke method to the Control class.  Invoke runs the specified delegate on the thread that create the control's window (or the parents window if it doesn't have one).

public void Invoke(System.Delegate delegate);
public void Invoke(System.Delegate delegate, object [] args);

The second form of Invoke takes an object array containing any parameters you wish to be passed into the delegate.  For those still not used to delegates, think of them as the .NET way to use function pointers.

A brief example

A simple example of using this is to create a new form, add a textbox and a button to it.  Call the textbox myTextbox.

At the top of the code file add another using statement for the threading library.

using System.Threading;

In the button's Click event place the following code.

Thread t = new Thread(new ThreadStart(SayHiThread));
t.IsBackground = true;
t.Start();

Now add this code to the form

private void SayHiThread()
{
	Invoke(new SayHiDelegate(SayHi), new object [] { "Hello from the thread" });
}

private void SayHi(string msg)
{
	myTextbox.Text = msg;
}

Outside of the form's class add this declaration

public delegate void SayHiDelegate(string msg);

Run the application and click the button, the textbox should now say "Hello from the thread".

What it did

Well that probably confused you more than it helped so I'll try to explain piece by piece what it does.

The Invoke method requires an instance of a delegate.  A delegate is nothing more than a type-safe function pointer.  You declare a delegate by creating the function signature you wish to have, then preceding the signature with the delegate keyword.  In the example above the function will take a string as its only parameter and return nothing.  You create a new delegate instance as if you were creating an instance of a class, except you pass in the name of the method you want the delegate to call.

The code inside of the button's click event creates a new thread, sets it as a background thread, then runs it.  All the thread does is run the function SayHiThread.  The thread only does one thing, it calls Invoke on the form (since SayHiThreadis a member of the form it calls the form's Invoke method).   The Invoke method takes an instance of a delegate, and an object array containing the parameters to give to the delegate.  In this case there is only one parameter; a string. 

To sum it up, Invoke calls the function which the delegate points to, passing in the parameters in the object array.

Summary

When you get down to it the hardest part of writing the code to interact with the UI from another thread is getting to understand delegates and how to use them.  As always, if there are any questions e-mail me or post them below. The source/demo show a example that's a bit more advanced, but still nothing too advanced.

This article, along with any associated source code and files, is licensed under The BSD License