代码之家  ›  专栏  ›  技术社区  ›  Benjol

串行调用异步方法

  •  2
  • Benjol  · 技术社区  · 16 年前

    void Transform<X,Y>(X x, Action<Y> resultCallback) {...}
    

    我想做的是把一个Xs列表转换成一个Ys列表。

    问题是,即使转换方法是异步的,也必须串行调用它(即,在使用下一个值调用它之前,我必须等待回调)。

    我想可能有办法通过继续传球。。。

    我忘记指定我不想阻塞调用(GUI)线程。

    2 回复  |  直到 16 年前
        1
  •  4
  •   Reed Copsey    16 年前

    如果将其包装在helper类中,则可以使helper“同步”您的值:

    public class AsyncWrapper<X,Y>
    {
        ManualResetEvent mre;
        private Y result; 
    
        public Y Transform(X x, YourClass yourClass)
        {
            mre = new ManualResetEvent(false);
            result = default(Y);
    
            yourClass.Transform<X,Y>(x, this.OnComplete);
            mre.WaitOne();
            return result;
        }
    
        void OnComplete(Y y)
        {
            result = y;
            mre.Set();
        }        
    }
    

    // instance your class with the Transform operation
    YourClass yourClass = new YourClass();
    
    AsyncWrapper<X,Y> wrapper = new AsyncWrapper<X,Y>();
    
    foreach(X x in theXCollection)
    {
         Y result = wrapper.Transform(x, yourClass);
    
         // Do something with result
    }
    

    编辑:

    // Start "throbber"
    Task.Factory.StartNew () =>
    {
        // instance your class with the Transform operation
        YourClass yourClass = new YourClass();
    
        AsyncWrapper<X,Y> wrapper = new AsyncWrapper<X,Y>();
    
        foreach(X x in theXCollection)
        {
             Y result = wrapper.Transform(x, yourClass);
    
             // Do something with result
        }
    }).ContinueWith( t =>
    {
        // Stop Throbber
    }, TaskScheduler.FromCurrentSynchronizationContext());
    

    这将在后台线程上启动整个(现在是同步的)进程,并在完成后禁用UI线程上的“throbber”(来自注释)。

    如果您控制了所有这些代码,那么您可以使转换过程从一开始就同步,然后像上面一样将其移到后台线程中,从而避免了对包装器的需要。

        2
  •  1
  •   Benjol    16 年前

    正如我在问题中暗示的那样,我想知道使用连续传递的解决方案。以下扩展方法允许我有一个相当“漂亮”的用法:

    public static class Extensions
    {
        //Using an asynchronous selector, calculate transform for 
        //  input list and callback with result when finished
        public static void AsyncSelect<TIn, TOut>(this List<TIn> list, 
                  Action<TIn, Action<TOut>> selector, 
                  Action<List<TOut>> callback)
        {
            var listOut = new List<TOut>();
            list.AsyncSelectImpl(listOut, selector, callback);
        }
    
        //internal implementation - hides the creation of the output list
        private static void AsyncSelectImpl<TIn, TOut>(this List<TIn> listIn, 
                  List<TOut> listOut, 
                  Action<TIn, Action<TOut>> selector, 
                  Action<List<TOut>> callback)
        {
            if(listIn.Count == 0)
            {
                callback(listOut); //finished (also if initial list was empty)
            }
            else
            {
                //get first item from list, recurse with rest of list
                var first = listIn[0];
                var rest = listIn.Skip(1).ToList();
                selector(first, result => { 
                                listOut.Add(result); 
                                rest.AsyncSelectImpl(listOut, selector, callback); 
                        });
            }
        }
    }
    

        (...)
        //(For a Transform which performs int -> string)
        Throbber.Start();
        inList.AsyncSelect<int,string>(Transform, WhenDone);
    }
    private void WhenDone(List<string> outList)
    {
        Throbber.Stop();
        //do something with outList
    }
    

    一个明显的限制是堆栈溢出-就我的目的而言,这不会是一个问题(我在几十个项目中,而不是数千个)。请在评论中加上任何其他引人注目的家伙!

    推荐文章