Question

I’ve got a code block that has to be executed in the same thread as the window. So I’d like call Form.Invoke for this block. But the method, containing the code block, can be called from different threads and one of them is the window thread.

So my question is: Is it ok to just use Form.Invoke although the method might be called already in the right thread? Or does this generate an overhead or even be a possible source of error?

Answer 1

Yes it is fine to call Invoke from the thread that owns the handle.

The overwhelming majority of code samples suggest that you should test InvokeRequired before deciding whether or not to call Invoke.

if (control.InvokeRequired) 
{
    control.Invoke(action);
}
else
{    
    action();
}

However, this leads to rather cluttered code and if you must support calls from non-GUI threads then I recommend that you simply call Invoke directly in all cases. There is a small overhead versus calling InvokeRequired and then the delgate directly – see Hans Passant’s comments to the question. However, so long as the delegate is performing significant work, or this code is not in a hot spot, the overhead should matter less than the code clarity.

What’s more InvokeRequired can give misleading results in the control’s handle has not yet been allocated. The documentation states:

If the control’s handle does not yet exist, InvokeRequired 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, the
InvokeRequired method returns false.

This means that InvokeRequired can return false if Invoke is not
required (the call occurs on the same thread), or if the control was
created on a different thread but the control’s handle has not yet
been created.

In the case where the control’s handle has not yet been created, you
should not simply call properties, methods, or events on the control.
This might cause the control’s handle to be created on the background
thread, isolating the control on a thread without a message pump and
making the application unstable.

You can protect against this case by also checking the value of
IsHandleCreated when InvokeRequired returns false on a background
thread. If the control handle has not yet been created, you must wait
until it has been created before calling Invoke or BeginInvoke.
Typically, this happens only if a background thread is created in the
constructor of the primary form for the application (as in
Application.Run(new MainForm()), before the form has been shown or
Application.Run has been called.

So I would take the advice from the final quoted paragraph above and replace the risky InvokeRequired code above with:

control.Invoke(action);