异步调用轻量级封装AsynCaller

    当UI动作引发一个耗时的计算时，我们经常需要将这个耗时的过程放到后台线程中去完成，然后获取该过程的结果。使用.NET提供的默认设施，无论是使用Thread还是使用异步调用，细节都比较繁琐。在前几天的blog上也看到了有些兄台的解决方案，但是觉得还不够好用，于是自己封了一个AsynCaller。
    AsynCaller通过事件来通知外部异步调用的结果，IAsynCaller接口如下：

    public   interface  IAsynCaller
    {
         // Delegate用于动态调用目标方法
         void  Initialize(Delegate method , object [] args) ;

         void  Start() ;   // 启动异步操作
         void  Cancel() ;  // 取消操作

         event  CBackTaskCompleted   TaskCompleted ;
         event  CBackExceptionThrown ExceptionThrown ;
         event  CBackTaskCanceled    TaskCanceled ;
    }

     public   delegate   void  CBackTaskCompleted( object  result) ;
     public   delegate   void  CBackExceptionThrown(Exception ee) ;
     public   delegate   void  CBackTaskCanceled() ;

    上面的接口清晰易懂，所需要注意的就是Initialize方法，它的第一个参数是需要进行异步调用的目标方法的委托，Delegate就像一个万能的delegate，它可以匹配到任何签名的方法。
    接口出来后，其实现AsynCaller就很容易写了。

public class AsynCaller :IAsynCaller
    {
        private Delegate target  = null;
        private object[] theArgs = null;        
        private Thread   backThread = null ;
        private bool     canceled = false ;

        private CBackTaskCompleted     taskCompleted;
        private CBackExceptionThrown exceptionThrown;
        private CBackTaskCanceled    taskCanceled ;
        
        #region IAsynCaller 成员
        public void Initialize(Delegate method ,object[] args)
        {
            this.target = method ;
            this.theArgs = args ;
        }

        public void Start()
        {
            this.backThread = new Thread(new ThreadStart(this.BackThread)) ;
            this.backThread.Start() ;
        }

        public void Cancel()
        {    
            this.canceled = true ;
            this.backThread.Abort() ;
        }

        #region BackThread
        private void BackThread()
        {
            try
            {
                object result = this.target.DynamicInvoke(this.theArgs) ;//动态调用
                this.ActivateTaskCompleted(result) ;
            }
            catch(Exception ee)
            {
                if((this.canceled) || (ee is ThreadAbortException)) //任务被取消
                {
                    this.ActivateTaskCanceled() ;
                }
                else
                {
                    this.ActivateExceptionThrown(ee) ;
                }
            }
        }
        #endregion
        
        #region event
        private void ActivateTaskCompleted(object result)
        {
            if(this.taskCompleted != null)
            {
                this.taskCompleted(result) ;
            }
        }

        private void ActivateExceptionThrown(Exception ee)
        {
            if(this.exceptionThrown != null)
            {
                this.exceptionThrown(ee) ;
            }
        }

        private void ActivateTaskCanceled()
        {
            if(this.taskCanceled != null)
            {
                this.taskCanceled() ;
            }
        }

        public event CBackTaskCompleted TaskCompleted
        {
            add
            {
                this.taskCompleted += value ;
            }
            remove
            {
                this.taskCompleted -= value ;
            }
        }

        public event CBackTaskCanceled TaskCanceled
        {
            add
            {
                this.taskCanceled += value ;
            }
            remove
            {
                this.taskCanceled -= value ;
            }
        }

        public event CBackExceptionThrown ExceptionThrown
        {
            add
            {
                this.exceptionThrown += value ;
            }
            remove
            {
                this.exceptionThrown -= value ;
            }
        }
        #endregion

        #endregion

    }

    下面给出一个示例来说明如何使用IAsynCaller。
    比如在一个Form中，有两个按钮，一个用于启动异步调用，一个用于取消操作。首先写一个耗时的方法，用于异步调用：

        private   void  ComputeTask( int  count)
        {
             for ( int  i = 0  ;i <  count ;i ++ )
            {
                Thread.Sleep( 500 ) ;
                 this .label1.Text  =   string .Format( " 第{0}次 "  ,i) ;
            }
        }

    然后在Form中添加成员变量：

private  IAsynCaller theAsynCaller  =   null  ;

    在构造函数中，初始化theAsynCaller，并预定对应的事件：

            object [] args  =  { 30 } ;
             this .theAsynCaller  =   new  AsynCaller() ;
             this .theAsynCaller.Initialize( new  CBack1( this .ComputeTask) ,args) ;

             this .theAsynCaller.TaskCanceled  +=   new  CBackTaskCanceled(theAsynCaller_TaskCanceled);
             this .theAsynCaller.TaskCompleted  += new  CBackTaskCompleted(theAsynCaller_TaskCompleted);

    事件处理函数如下：

        private   void  button1_Click( object  sender, System.EventArgs e)
        {
             this .theAsynCaller.Start() ;
        }

         private   void  button2_Click( object  sender, System.EventArgs e)
        {
             this .theAsynCaller.Cancel() ;
        }

         private   void  theAsynCaller_TaskCanceled()
        {
            MessageBox.Show( " Task Canceled " ) ;
        }

         private   void  theAsynCaller_TaskCompleted( object  result)
        {
            MessageBox.Show( " Task complete " ) ;
        }

    为了简化，上面的示例在后台线程中调用的了UI显示，这在真正的应用中是万万不可的。同时要注意，上面的示例中，IAsynCaller接口事件的事件处理函数也是在后台线程中调用的，也存在同样的问题。