Most Concise way to Invoke a void Method Asynchronously

Question

Hi all,

I have a method which I would like to invoke asynchronously:

void Foo()
{
}

I can indeed invoke this asynchronously by the following:

delegate void DVoidMethod();
DVoidMethod FooDelegate = new DVoidMethod(Foo);
FooDelegate.BeginInvoke(null,null);

Has anyone got any alternatives?

I think three lines of code is too much?

Answer 1

Disclaimer:

Don't use this in real code. This is just an attempt to shorten the code OP mentioned. To do real async calls without getting results back, use:

ThreadPool.QueueUserWorkItem(stateObject => Foo());

---

Use Action and Func delegates in the framework:

new Action(Foo).BeginInvoke(null, null);

Action<T> has been around since 2.0. Other variants are added in 3.5. On 2.0, you can, however, declare a bunch of them somewhere manually for further use; or even better, use LINQBridge.

Answer 2

You can knock it down to two lines (in .Net 1.1 and earlier) with simply:

delegate void DVoidMethod();
new FooDelegate(DVoidMethod).BeginInvoke(null, null)

But in the 2.0 and later versions.. the syntax from Mehrdad works.

Refer to the Action delegate for 2.0 and later at MSDN at:

http://msdn.microsoft.com/en-us/library/018hxwa8(VS.80).aspx

Answer 3

How about:

ThreadPool.QueueUserWorkItem(new WaitCallback(Foo));

Answer 4

Without using Action and Func you could use the MethodInvoker in the case of the void () delegate:

new MethodInvoker(Foo).BeginInvoke(null, null);

Also, it should be noted that if you use the BeginInvoke method you have to call EndInvoke when the delegate has completed execution.. so this line above will have to change to either use a callback or you need to keep a reference to the delegate.. Like so:

MethodInvoker mi = null;
IAsyncResult ar = null;

ar = (mi = new MethodInvoker(Foo)).BeginInvoke(null,null);


.. sometime later after the delegate has completed executing
mi.EndInvoke(ar);

This is true whenever you use BeginInvoke. So I guess in the end I wouldn't recommend using the BeginInvoke method..

@Steven's solution using the ThreadPool is a much better solution in my opinion.. and his oviously:)

Answer 5

Strictly speaking I wouldn't worry about the number of lines of code something takes from a performance perspective because you have no idea how much actual code is behind the functions you're calling.

Answer 6

Old thread, but I couldn't resist piling on.

You indeed must call EndInvoke to avoid leaks, even if you're not using the result or reacting to the method's completion. But that doesn't mean it has to be ugly.

BeginInvoke expects an AsyncCallback as the callback parameter. An AsyncCallback's signature is a void that takes an IAsyncResult. EndInvoke has that signature, so:

    //waste some time...
    void Foo() {}
    void InvokeFoo()
    {
        Action fooer = () => Foo();
        fooer.BeginInvoke(fooer.EndInvoke, null);            
    }
    void InvokeFoo2()
    {
        // or, less concise but some consider more readable:
        Action fooer = new Action(Foo); //...invoke doesn't change
    }