执行异步方法的问题

Question

这段代码有问题

 if(Handlers.Count==0)
                {
                    GetHandlers();
                    while (_handlers.Count == 0)
                    {
                        Thread.Sleep(100);
                    }
                }
                return _showroomLogs;

这个方法执行:

 private void GetHandlers()
        {
            WebSerive.GetHandlersCompleted += new EventHandler<GetHandlersCompletedEventArgs>(OnGetHandlersCompleted);
            WebSerive.GetHandlersAsync(_app.HandlerId);
        }

但是对于这个方法:

private void OnGetHandlersCompleted(object sender, GetHandlersCompletedEventArgs e)
        {
            WebSerive.GetHandlersCompleted -= new EventHandler<GetHandlersCompletedEventArgs>(OnGetHandlersCompleted);
            _handlers = e.Result;
        }

我陷入了

的后执行

return _showroomLogs;

当然，如果我用While

删除这段

我必须做的是，在

之前执行OnGetHandlersAsync

 return _showroomLogs;

?

Answer 1

您需要认识到，一旦向序列引入异步操作，整个序列就会变成异步的。使用像Sleep这样的阻塞技术是99.99999%的错误选择。

重组:-

  private void GetHandlers(int handlerID, Action<IList<Handler>> returnResult)
  {
        EventHandler<GetHandlersCompletedEventArgs> eh = null;
        eh = (s, args) =>
        {
             WebSerive.GetHandlersCompleted -= eh;
             returnResult(args.Result);
        };
        WebSerive.GetHandlersCompleted += eh;
        WebSerive.GetHandlersAsync(handerlID);
 }

然后调用:-

 GetHandlers(_app.HandlerId, handlers =>
 {
      _handlers = handlers;
      // Do other stuff 
 });

编辑

让我在概念层面概述一下这里的基本问题。假设我有一个按钮点击事件，它调用FuncA。FuncA呼叫FuncB, FuncB呼叫FuncC

click -> FuncA -> FuncB -> FuncC

整个序列是同步的，它可能看起来像:-

 void Button_Click(object sender, EventArgs e)
 {
     FuncA();
     //Do other stuff
 }
 void FuncA()
 {
     var result = FuncB();
     //Do stuff with result;
 }
 string FuncB()
 {
     return FuncC() + " World";
 }
 string FuncC()
 {
     return "Hello";
 }

但是现在让我们把FuncC改成异步操作的东西。它立即返回，但它的返回值稍后才可用，它在完成后调用一个回调方法，该方法将结果作为参数。FuncB的问题是，它想返回一个值，但不能直到FuncC的异步操作完成。我们不需要让FuncB阻塞线程，而是需要以与FuncC相同的方式将FuncB转换为异步操作。整个过程需要一直到事件发生。它变成了:

 void Button_Click(object sender, EventArgs e)
 {
     FuncA(() =>
     {
         //Do other stuff after FuncA has completed
     });
 }
 void FuncA(Action callback)
 {
     FuncB(result =>
     {
         //Do stuff with result
         // then finally
         callback();
     });
 }
 void FuncB(Action<string> returnResult)
 {
     FuncC(result => returnResult(result + " World"));
 }
 void FuncC(Action<string> returnResult)
 {
     Dispatcher.BeginInvoke(() => returnResult("Hello"));
 }

当只涉及一个实际的异步操作时，此模式将适用。当您在同一个操作中有一系列实际的异步调用时，事情开始变得非常奇怪。为了避免过多的回调嵌套，需要一些框架的帮助。我把我的命名为AsyncOperationService，你可以在这里读到。