[Silverlight入门系列]同步调用多个WCF RIA Services的异步方法

对多个异步调用要进行顺序控制是个麻烦的事情，但这也是我们经常要碰到的情形。例如，往往需要在一个异步任务完成之后才能开始另一个异步任务。所以，我们往往需要在异步任务的OnCompletedCallback里面加上下一个任务的处理，最后写出来的代码就像这样难看：

var securityClient = new SecurityServiceClient();

securityClient.IsLoggedInCompleted += (s,e) =>
{
     var t2 = new SecurityServiceClient();

     t2.IsLoggedInCompleted += (s,e) =>
     {
          var t3 = new SecurityServiceClient();

          t3.IsLoggedInCompleted += (s,e) =>
          {
                var t4 = new SecurityServiceClient();

                t4.IsLoggedInCompleted += (s,e) =>
                {
                     var t5 = new SecurityServiceClient();

                     t5.IsLoggedInCompleted += (s,e) =>
                     {
                             var t6 = new SecurityServiceClient();

                             t6.IsLoggedInCompleted += (s,e) =>
                             {
                                  var t7 = new SecurityServiceClient();

                                  t7.IsLoggedInCompleted += (s,e) =>
                                  {
                                       //TODO:
                                  };

                                  t7.IsLoggedInAsync();
                             };

                             t6.IsLoggedInAsync();
                     };

                     t5.IsLoggedInAsync();
                };

                t4.IsLoggedInAsync();
          };

          t3.IsLoggedInAsync();
     };

     t2.IsLoggedInAsync();
};

securityClient.IsLoggedInAsync();

不光难看，如果是个N重循环，这样写是不可以工作的。解决办法就是同步调用WCF RIA Service的方法。大家知道，WCF RIA Services的方法必须在客户端异步调用，没有同步模式。所以我们只能人工处理一下了。（请注意：本文思路参考了StackOverflow的这篇回答。）

封装IAction接口：

public interface IAction
{
    void Execute();
    event EventHandler<ProgressChangedEventArgs> ProgressChanged;
    event EventHandler Completed;
}

异步操作类：AsynAction

public class AsynAction : IAction
{
    private Action _action;
    private readonly bool _autoComplete;

    public AsynAction(bool autoComplete = true)
    {
        _autoComplete = autoComplete;
    }

    public AsynAction(Action action, bool autoComplete = true):this(autoComplete)
    {
        _action = action;
        _autoComplete = autoComplete;
    }

    public void SetAction(Action action)
    {
        _action = action;
    }

    public void Execute()
    {
        if (_action == null) return;

        _action();

        if (!_autoComplete && Completed != null)
        {
            Completed(this, EventArgs.Empty);
        }
    }

    public event EventHandler<ProgressChangedEventArgs> ProgressChanged;
    public event EventHandler Completed;

    public void OnCompleted()
    {
        if (Completed != null)
            Completed(this, new EventArgs());
    }
}

对多个异步任务的列举控制类：AsynActionsEnumerator

public class ProgressChangedEventArgs : EventArgs
{
    public int Progress { get; set; }
    public string Status { get; set; }
}

public class AsynActionsEnumerator : IAction
{
    readonly IEnumerator<IAction> _enumerator;

    public AsynActionsEnumerator(IEnumerator<IAction> enumerator)
    {
        _enumerator = enumerator;
    }

    public event EventHandler<ProgressChangedEventArgs> ProgressChanged;

    private void OnProgressChanged(int progress, string status)
    {
        if (ProgressChanged != null)
            ProgressChanged(this, new ProgressChangedEventArgs { Progress = progress, Status = status });
    }

    public event EventHandler Completed;

    private void OnCompleted()
    {
        if (Completed != null)
            Completed(this, new EventArgs());
    }

    private int _index = 0;

    public void Execute()
    {
        //If the enumerator gives us another action,
        //hook up its Completed event to continue the
        //the chain, then execute it.
        if (_enumerator.MoveNext())
        {
            _enumerator.Current.Completed += delegate { Execute(); };
            OnProgressChanged(_index++, String.Empty);
            _enumerator.Current.Execute();
        }
        else     //If the enumerator didn't give us another action, we're finished.
        {
            _index = 0;
            OnCompleted();
        }
    }

}

添加多个异步任务:

private IEnumerator<IAction> GetAsycActionsEnumerator()
{
   for(int i = 0; i < 10; i++)
   {
       var task = new AsynAction();
       task.SetAction(() =>
       {
           var securityClient = new SecurityServiceClient();

           securityClient.IsLoggedInCompleted += (s,e) =>
             {
                 //TODO: your logic here
                 //.......
                 task.OnCompleted();
             };

           securityClient.IsLoggedInAsync();
      });
      yield return task;
   }
}

同步执行多个异步任务：

var emu = new AsynActionsEnumerator(GetAsycActionsEnumerator());
emu.Execute();

使用AutoResetEvent或Queue来实现

另外一个很容易想到的思路自然是使用Queue或者线程同步（例如：AuteResetEvent，ManualResetEvent等），代码例如：

private resetEvent = new AutoResetEvent(false);

private void Process()
{
        var securityClient = new SecurityServiceClient();

     securityClient.IsLoggedInCompleted += (s,e) =>
       {
         //TODO: your logic here
         //.......
         resetEvent.Set();
     };

     securityClient.IsLoggedInAsync();
     resetEvent.WaitOne();

     //TODO: some more work....

}

 

 

使用Queue思路也是差不多，加上一个Enque/Deque而已。

为什么上面的代码在Silverlight和WCF RIA Services下不工作？

上面的代码（AutoResetEvent, Queue）很简单，但运行一下便知道以上代码在Silverlight4+WCF RIAServices中根本不工作。为什么？因为WaitOne会阻塞主UI线程，并且会阻塞WCF RIAServices的回调（callBack），也就是说，WCF RIAServices的回调（callBack）只有在Silverlight的UI主线程没有阻塞的情况下才工作。Silverlight不足的地方就在此，（至少对Silverlight4-还是如此，Silverlight5会改进）。事实上Silverlight对WCF RIAServices的通信调用发生在UI线程上，每次只可以有一个call，不能并行调用WCF RIAServices，不信你可以用Fiddler跟踪一下。而Silverlight的UI主线程要负责的事情可多了：处理用户输入输出、运行动画等等。这不可避免产生主线程阻塞，甚至动画卡壳，这是不可避免的，因为主线程要负责太多事情了，而它在同一时刻只能做一件事情（单线程）。总之，这是Silverlight4的局限性和WCF RIAServices的局限性，还好，微软会在SIlverlight5中改善这些，引入主UI线程以外的复合线程（须GPU支持，具体看这贴）。

总结

异步任务处理和控制等在.NET 4.0下面非常简单，微软提供了很多强大的东东来处理它，什么ConcurrentQueue, PriorityQueue, TPL…..但在Silverlight下就受限制了，Silverlight本身只是一个客户端模型，使用一个受限的.NET Framework，而WCF RIA Service又是一个减配版的WCF Service。本文就是在此背景下的问题而写的。