Invoke or BeginInvoke cannot be called on a control until the window handle has been created

Question

I have a SafeInvoke Control extension method similar to the one Greg D discusses here (minus the IsHandleCreated check). I am calling it from a `System.Windows.Forms.Form` as follows: ``` public void Show(string text) { label.SafeInvoke(()=>label.Text = text); this.Show(); this.Refresh(); } ``` Sometimes (this call can come from a variety of threads) this results in the following error: `System.InvalidOperationException` occurred `Message`= "Invoke or BeginInvoke cannot be called on a control until the window handle has been created." `Source`= "System.Windows.Forms" ``` StackTrace: at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) at System.Windows.Forms.Control.Invoke(Delegate method) at DriverInterface2.UI.WinForms.Dialogs.FormExtensions.SafeInvoke[T](T control, Action`1 action) in C:\code\DriverInterface2\DriverInterface2.UI.WinForms\Dialogs\For…

Accepted Answer

It's possible that you're creating your controls on the wrong thread. Consider the following documentation from MSDN:

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.

Let's see what this means for you. (This would be easier to reason about if we saw your implementation of SafeInvoke also)

Assuming your implementation is identical to the referenced one with the exception of the check against IsHandleCreated, let's follow the logic:

```
public static void SafeInvoke(this Control uiElement, Action updater, bool forceSynchronous)
{
    if (uiElement == null)
    {
        throw new ArgumentNullException("uiElement");
    }

if (uiElement.InvokeRequired)
    {
        if (forceSynchronous)
        {
            uiElement.Invoke((Action)delegate { SafeInvoke(uiElement, updater, forceSynchronous); });
        }
        else
        {
            uiElement.BeginInvoke((Action)delegate { SafeInvoke(uiElement, updater, forceSynchronous); });
        }
    }
    else
    {    
        if (uiElement.IsDisposed)
        {
            throw new ObjectDisposedException("Control is already disposed.");
        }

updater();
    }
}
```

Consider the case where we're calling `SafeInvoke` from the non-gui thread for a control whose handle has not been created.

`uiElement` is not null, so we check `uiElement.InvokeRequired`. Per the MSDN docs (bolded) `InvokeRequired` will return `false` because, even though it was created on a different thread, the handle hasn't been created! This sends us to the `else` condition where we check `IsDisposed` or immediately proceed to call the submitted action... from the background thread!

At this point, all bets are off re: that control because its handle has been created on a thread that doesn't have a message pump for it, as mentioned in the second paragraph. Perhaps this is the case you're encountering?

Invoke or BeginInvoke cannot be called on a control until the window handle has been created

Solution

Problem

Related problems