Anonymous method as parameter to BeginInvoke?

Question

Why can't you pass an anonymous method as a parameter to the BeginInvoke method ? I have the following code:

    private delegate void CfgMnMnuDlg(DIServer svr);
    private void ConfigureMainMenu(DIServer server,)
    {
        MenuStrip mnMnu = PresenterView.MainMenu;
        if (mnMnu.InvokeRequired)
        {
            mnMnu.BeginInvoke((CfgMnMnuDlg)ConfigureMainMenu, 
                                new object[] { server});
        }
        else
        {
            // Do actual work here
        }
    }

I'm trying to avoid declaring the delegate. Why can't I write somwthing like the below instead ? Or can I, and I just can't figure out the correct syntax? The below currently generates an "Argument type 'Anonymous method' is not assignable to parameter type 'System.Delegate' " Ok, that's right of course, but is there some other syntax I can use to do this (avoid having to declare a separate delegate in order to use BeginInvoke()?

(Being able to do this would fit in neatly with the concept of using anon methods/lamdas in place of explicit delegates which works so cleanly everywhere else.)

    private void ConfigureMainMenu(DIServer server,)
    {
        MenuStrip mnMnu = PresenterView.MainMenu;
        if (mnMnu.InvokeRequired)
        {
            mnMnu.BeginInvoke(  //  pass anonymous method instead ?
                 delegate(DIServer svr) { ConfigureMainMenu(server);},     
                 new object[] { server});
        }
        else
        {
            // Do actual work here
        }
    }

Answer 1

I've tried a bunch of different methods but none work. ie...

// Fails -- cannot convert lamda to System.Delegate
mnMnu.BeginInvoke( (DIServer svr)=> {ConfigureMainMenu(server);}, new object[] server);
// Fails -- cannot convert anonymous method to System.Delegate
mnMnu.BeginInvoke( new delegate(DIServer svr){ConfigureMainMenu(server);}, new object[] server);

So, the short answer is no. You could create short helper delegates in the given context and use lamdas to make it a bit neater but that's pretty much it.

EDIT: Turns out I'm wrong. The methodinvoker answer below works. See this page

Answer 2

Shouldn't it be something like this (unverified):

mnMnu.BeginInvoke( svr => ConfigureMainMenu(svr), new object[] { server});

Answer 3

Try this:

control.BeginInvoke((MethodInvoker) delegate { /* method details */ });

Or:

    private void ConfigureMainMenu(DIServer server)
    {
        if (control.InvokeRequired)
        {
            control.BeginInvoke(new Action<DIServer >(ConfigureMainMenu), server);
        }
        else
        {
            /* do work */
        }

    }

Or:

private void ConfigureMainMenu(DIServer server)
{
    MenuStrip mnMnu = PresenterView.MainMenu;
    if (mnMnu.InvokeRequired)
    {
        // Private variable
        _methodInvoker = new MethodInvoker((Action)(() => ConfigureMainMenu(server)));
        _methodInvoker.BeginInvoke(new AsyncCallback(ProcessEnded), null); // Call _methodInvoker.EndInvoke in ProcessEnded
    }
    else
    {
        /* do work */
    }

}

Answer 4

You should be able to write something like this:

private void ConfigureMainMenu(DIServer server,)
{
    MenuStrip mnMnu = PresenterView.MainMenu;
    if (mnMnu.InvokeRequired)
    {
        mnMnu.BeginInvoke(new Action<DIServer>(ConfigureMainMenu), 
                            new object[] { server});
    }
    else
    {
        // Do actual work here
    }
}

Answer 5

You could write an extension method that would wrap anonymous methods, and even take care of the InvokeRequired semantics:

public static void InvokeAction(this Control ctl, Action a)
{
    if (!ctl.InvokeRequired)
    {
        a();
    }
    else
    {
        ctl.BeginInvoke(new MethodInvoker(a));
    }
}

This would allow you to do:

control.InvokeAction(delegate() { ConfigureMainMenu(server); });

Answer 6

For completely anonymous methods with a limited number of parameters:

Func<int, int?> caller = new Func<int, int?>((int param1) =>
   {
      return null;
   });

caller.BeginInvoke(7, new AsyncCallback((IAsyncResult ar) =>
{
   AsyncResult result = (AsyncResult)ar;
   Func<int, int?> action = (Func<int, int?>)result.AsyncDelegate;
   action.EndInvoke(ar);
}), null);

You can use one of the other Func delegate types as needed.