How to invoke a UI method from another thread

.net, c#, multithreading, timer, winforms

Solution

I guess your code is just a test so I won't discuss about what you do with your timer. The problem here is how to do something with an user interface control inside your timer callback.

Most of `Control`'s methods and properties can be accessed only from the UI thread (in reality they can be accessed only from the thread where you created them but this is another story). This is because each thread has to have its own message loop (`GetMessage()` filters out messages by thread) then to do something with a `Control` you have to dispatch a message from your thread to the main thread. In .NET it is easy because every `Control` inherits a couple of methods for this purpose: `Invoke/BeginInvoke/EndInvoke`. To know if executing thread must call those methods you have the property `InvokeRequired`. Just change your code with this to make it works:

if (elapsedTime < MaxTime)
{
    this.BeginInvoke(new MethodInvoker(delegate 
    {
        this.lblElapsedTime.Text = elapsedTime.ToString();

        if (ElapsedCounter % 2 == 0)
            this.lblValue.Text = "hello world";
        else
            this.lblValue.Text = "hello";
    }));
}

Please check MSDN for the list of methods you can call from any thread, just as reference you can always call `Invalidate`, `BeginInvoke`, `EndInvoke`, `Invoke` methods and to read `InvokeRequired` property. In general this is a common usage pattern (assuming `this` is an object derived from `Control`):

void DoStuff() {
    // Has been called from a "wrong" thread?
    if (InvokeRequired) {
        // Dispatch to correct thread, use BeginInvoke if you don't need
        // caller thread until operation completes
        Invoke(new MethodInvoker(DoStuff));
    } else {
        // Do things
    }
}

Note that current thread will block until UI thread completed method execution. This may be an issue if thread's timing is important (do not forget that UI thread may be busy or hung for a little). If you don't need method's return value you may simply replace `Invoke` with `BeginInvoke`, for WinForms you don't even need subsequent call to `EndInvoke`:

void DoStuff() {
    if (InvokeRequired) {
        BeginInvoke(new MethodInvoker(DoStuff));
    } else {
        // Do things
    }
}

If you need return value then you have to deal with usual `IAsyncResult` interface.

How it works?

A GUI Windows application is based on the window procedure with its message loops. If you write an application in plain C you have something like this:

MSG message;
while (GetMessage(&message, NULL, 0, 0))
{
    TranslateMessage(&message);
    DispatchMessage(&message);
}

With these few lines of code your application wait for a message and then delivers the message to the window procedure. The window procedure is a big switch/case statement where you check the messages (`WM_`) you know and you process them somehow (you paint the window for `WM_PAINT`, you quit your application for `WM_QUIT` and so on).

Now imagine you have a working thread, how can you call your main thread? Simplest way is using this underlying structure to do the trick. I oversimplify the task but these are the steps:

- Create a (thread-safe) queue of functions to invoke (some examples here on SO).

- Post a custom message to the window procedure. If you make this queue a priority queue then you can even decide priority for these calls (for example a progress notification from a working thread may have a lower priority than an alarm notification).

- In the window procedure (inside your switch/case statement) you understand that message then you can peek the function to call from the queue and to invoke it.

Both WPF and WinForms use this method to deliver (dispatch) a message from a thread to the UI thread. Take a look to this article on MSDN for more details about multiple threads and user interface, WinForms hides a lot of these details and you do not have to take care of them but you may take a look to understand how it works under the hood.

Problem

Original source

Related problems

• Is it necessary to dispose System.Timers.Timer if you use one in your application?
• C# creating function queue