Performance issues when updating UI without checking InvokeRequired first?

Question

I have gotten a bit lazy(it's sometimes good) and started updating WinForms UI by invoking a callback without checking InvokeRequired first.

Are there a performance issues or considerations that I should be aware of?

    private delegate void SetStatusEventHandler(string statusMessage);
    private void SetStatus(string statusMessage)
    {
        Invoke((MethodInvoker) (() =>
        {
            resultLabel.Text = statusMessage;
        }));

        //  - vs -

        if (InvokeRequired)
        {
            SetStatusEventHandler cb = SetStatus;
            Invoke(cb, statusMessage);
        }
        else
        {
            resultLabel.Text = statusMessage;
        }
    }

[EDIT]: Most of times that a method that calls "invoke" will be called at most like say 10~20 times a second with a wide interval inbetween.

[UPDATE] Settled with the following extension method

public static class SmartInvoker
{
    public static void InvokeHandler(this Control control, MethodInvoker del)
    {
        if (control.InvokeRequired)
        {
            control.Invoke(del);
            return;
        }
        del();
    }
}

...

    private void SetStatus(string statusMessage)
    {
        this.InvokeHandler(() => resultLabel.Text = statusMessage);
    }

I guess finding out how to manage extension method classes is another topic I need to dig in. Thank you for your help

Answer 1

EDIT: See the comments for debate about the whole posting vs immediately dispatching malarky.

Either way, my answer is actually the same: unless this is happening hugely often unnecessarily (i.e. most of the time you're on the UI thread to start with, and it's attached to something like a mouse movement handler) I wouldn't worry. It certainly makes the code simpler. If this is going to be invoked very often, I'd measure and test more :)

Invoke is faster with an EventHandler or MethodInvoker delegate than with others. I don't know if there's any difference between the two - you may want to check.

You can make this even simpler by writing an extension method, e.g.

public static void InvokeHandler(this Control control, MethodInvoker handler)
{
     control.Invoke(handler);
}

Then you can make your code:

private void SetStatus(string statusMessage)
{
    this.InvokeHandler(delegate
    {
        resultLabel.Text = statusMessage;
    });
}

or

private void SetStatus(string statusMessage)
{
    InvokeHandler(() => resultLabel.Text = statusMessage);
}

That way you don't need to specify the delegate type.

Answer 2

Why not just add an extension method so you don't have to think about it anymore?

public static object SmartInvoke(this Control control, MethodInvoker del) {
  if ( control.InvokeRequired ) {
    control.Invoke(del);
    return;
  }
  del();
}

Now your code becomes

private void SetStatus(string statusMessage) {
  this.SmartInvoke(() => resultLabel.Text = statusMessage);
}

Answer 3

I believe it just prevents an unnecessary post if you're already on the same thread. So if that would be the most common scenario (being on the correct thread), it might cause a small performance hit by not checking, but I dont believe its actually required.