在单个扩展方法中正确开始和结束调用

Question

我想与其他人仔细检查这是否是创建启动异步进程并返回一个函数的正确方法，该函数在调用时本质上等待该进程并获取结果。

    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);
        };
    }

本质上我想像这样使用它（伪代码）：

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

不确定在这种情况下我是否需要担心等待 WaitHandles 。也不确定是否有必要传递回调。我还认为这构成了关闭？

编辑

结束了，

    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); 
        };
    }

这似乎运作良好。该回调检查是否已调用 EndInvoke，如果没有，则调用它。否则，在返回的委托中调用 EndInvoke。

第二次编辑

这是我的最新尝试——还没有向我抛出任何错误，并且似乎处理得很好。我无法让它在委托返回 function.EndInvoke() 结果的情况下工作，但委托会等待，直到在匿名回调中调用 EndInvoke，然后再返回 R。Thread.Sleep() 可能不是最好的解决方案。还可以使用更多检查来确保在每种情况下实际分配给 R。

    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

这应该可行，但我不热衷于设计......这是基本问题。

如果调用了 myFunc，则不应在回调中调用 EndInvoke，但如果未调用 myFunc，因为您不关心返回值，则必须在回调中调用 EndInvoke。这使得 API 的使用变得不那么明显并且容易出错。

尽管它不太可能经常咬你，但随着你在那里的睡眠，它很活泼。这使用正确的同步原语来保证一切都会以正确的顺序发生。这是未经测试的代码，但应该可以工作

    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;
            }
        };
    }

Answer 2

我遇到了一种更简单的方法，您可以在调用站点（而不是在后台线程上）（重新）抛出异常：

    public static Func<R> Future<T, R>(this Func<T, R> func, T arg)
    {
        IAsyncResult result = func.BeginInvoke(arg, null, null);

        return () => func.EndInvoke(result);
    }

这对于操作来说几乎是相同的：

    public static Action Future<T>(this Action<T> action, T arg)
    {
        IAsyncResult result = action.BeginInvoke(arg, null, null);

        return () => action.EndInvoke(result);
    }

但是如果您没有任何需要对于结果，ThreadPool.QueueUserWorkItem() 更有效。