How to call a function though Control.BeginInvoke in a signal-slot-like fashion?

Question

I'd like a delegate that calls a function in a different thread when it is invoked. Currently, I'm using the following implementation:

delegate void someFunctionDelegate();
//...

someFunctionDelegate callBackFunction = someForm.SomeFunction;
someForm.Invoke(someFunctionDelegate);

However, I'd like a more compact form, combining both the someForm instance and the SomeForm.SomeFunction member function. I'm thinking of something like this:

var callBackFunction = new AsynchronousCrossThreadDelegate(someForm, SomeForm.SomeFunction);
callBackFunction(); // Should call someForm.BeginInvoke(SomeForm.SomeFunction);

Is there a way to do so in C#/.NET?

Update I'm looking for a solution that will work for functions with 0 or more parameters.

Answer 1

Would this help?

You'd just do:

var callBackFunction = AsynchronousCrossThreadDelegate.Create(someForm, SomeForm.SomeFunction);   
callBackFunction(); // Should call someForm.BeginInvoke(SomeForm.SomeFunction);   

instead.

public class AsynchronousCrossThreadDelegate
{
    public delegate void someFunctionDelegate(); 

    private Control _ctrl;
    private someFunctionDelegate _callback;

    private AsynchronousCrossThreadDelegate( Control ctrl, someFunctionDelegate callback )
    {
        _ctrl = ctrl;
        _callback = callback;
    }

    private void invoke()
    {
        _ctrl.BeginInvoke( _callback );
    }

    public static someFunctionDelegate Create( Control ctrl, someFunctionDelegate callback )
    {
        return (new AsynchronousCrossThreadDelegate( ctrl, callback )).invoke;
    }

}

Answer 2

Partly thanks to my discussion with danbystrom, I found a sufficient solution:

public static Action<T> MakeAsyncDelegate<T>(
    this Control form, Action<T> functionToCallAsynchronously)
{
    Action<T> ret = ((T t) => {
        form.BeginInvoke(functionToCallAsynchronously, t);
    });
    return ret;
}

This allows you to keep the client code clean:

Action<string> signal = form.MakeAsyncDelegate(form.SomeFunction);
signal("some string");

Regrettably, the caller has to explicitly specify the template parameter, as the compiler cannot infer it automatically (see this article), neither can the compiler check whether the type really matches the function signature (in C++ this can be done).