Question

I want to double check with others whether this would be the correct way to create an extension method that begins an asynchronous process, and returns a function that when invoked essentially waits on that process and gets the result.

    public static Func<R> HandleInvoke<T, R>(this Func<T, R> function, T arg, Action<IAsyncResult> callback)
    {
        IAsyncResult result = function.BeginInvoke(arg, new AsyncCallback(callback), function);

        return delegate
        {
            return function.EndInvoke(result);
        };
    }

Essentially I want to use it like such (pseudo code):

Func<R> myFunc = (some delegate).HandleInvoke(arg, callback);  
                     // at this point the operation begins, but will be nonblocking

                     // do other stuff

var result = myFunc();   // now I am deciding to wait on the result, which is blocking

Wasnt sure if I need to worry about waiting on WaitHandles in this situation or not. Also not sure if passing in a callback would even be necessary. Also I think this constitutes a closure?

EDIT

Ended up with this,

    public static Func<R> HandleInvoke<T, R>(this Func<T, R> function, T arg)
    {
        IAsyncResult asyncResult = function.BeginInvoke(arg, iAsyncResult =>
            {
                if (!(iAsyncResult as AsyncResult).EndInvokeCalled)
                {
                    (iAsyncResult.AsyncState as Func<T, R>).EndInvoke(iAsyncResult);
                }

            }, function); 

        return delegate
        {
            WaitHandle.WaitAll(new WaitHandle[] { asyncResult.AsyncWaitHandle }); 

            return function.EndInvoke(asyncResult); 
        };
    }

Which seems to work well. The callback checks if EndInvoke has been called, and if not, calls it. Otherwise EndInvoke is called within the returned delegate.

2ND EDIT

Here is my latest attempt — hasnt thrown any errors at me yet and seems to handle it well. I couldn’t get it to work where the delegate returned the function.EndInvoke() result, but the delegate waits until EndInvoke has been called in the anonymous callback before returning R. Thread.Sleep() probably isnt the best solution, though. Also could use more checking to make sure that R was actually assigned to in each case.

    public static Func<R> HandleInvoke<T, R>(this Func<T, R> function, T arg)
    {
        R r = default(R); 

        IAsyncResult asyncResult = function.BeginInvoke(arg, result =>
            {
                r = (result.AsyncState as Func<T, R>).EndInvoke(result);

            }, function); 


        return delegate
        {
            while (!(asyncResult as AsyncResult).EndInvokeCalled)
            {
                Thread.Sleep(1); 
            }

            return r; 
        };
    }

Answer 1

This should work but I’m not keen on the design… Here is the basic problem.

If myFunc is called than you should not call EndInvoke in the callback but if myFunc is not called, because you don’t care about the return value then EndInvoke must be called in the callback. This makes using the API non-obvious and error prone.

with the sleep you have in there it is racy, though it isn’t likely to bite you very often. This uses proper synchronization primitives to guarantee that everything will happen in the right order. This is untested code, but should work

    public static Func<R> HandleInvoke<T, R>(this Func<T, R> function, T arg)
    {
        R retv = default(R);
        bool completed = false;

        object sync = new object();

        IAsyncResult asyncResult = function.BeginInvoke(arg, 
            iAsyncResult =>
            {
                lock(sync)
                {
                    completed = true;
                    retv = function.EndInvoke(iAsyncResult);
                    Monitor.Pulse(sync); // wake a waiting thread is there is one
                }
            }
            , null);

        return delegate
        {

            lock (sync)
            {
                if (!completed) // if not called before the callback completed
                {
                    Monitor.Wait(sync); // wait for it to pulse the sync object
                }
                return retv;
            }
        };
    }