C# 委托异步调用及回调解析

本文将主要讲解委托的“同步调用”、“异步调用”、“异步回调”。

什么是委托、回调？

委托是一种方法类型，委托可以把方法的具体实现交给另一个类（委托对象）来管理。在一个类中调用另一个类的方法，此过程叫回调。

1、如下代码，首先定义一个方法模拟实际开发过程中比较耗时的业务逻辑处理过程。

 /// <summary>
        /// 模拟业务中比较耗时的操作
        /// </summary>
        /// <param name="sParm"></param>
        private void DoSomething(string sParm)
        {
            long Result = 0;

            Console.WriteLine($"this is DoSomething Start  {Thread.CurrentThread.ManagedThreadId}");
            for (int i = 0; i < 1000000; i++)
            {
                Result += i;
            }
            Thread.Sleep(2000);
            Console.WriteLine($"this is Domething End {Thread.CurrentThread.ManagedThreadId}");
        }

 

2、Invoke实现委托同步调用，代码如下。

 #region 委托调用Invoke
        /// <summary>
        /// 同步方法执行顺序依次是 
        /// button1_Click_同步方法  start
        /// this is DoSomething Start
        /// this is DoSomething End
        /// button1_Click_同步方法  End
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSync_Click(object sender, EventArgs e)
        {
            Console.WriteLine("btnSync_Click同步方法  start");
            Action<string> action = this.DoSomething;
            action.Invoke("btnSync_Click");  //;利用委托调用Domething方法，这块实际上和直接调用Domething方法没什么区别
            Console.WriteLine("btnSync_Click同步方法  End");
        }

#endregion

从控制台打印信息可以很直观的看到，同步调用时代码的执行顺序依次从上到下，一直等到被调用的DoSomething方法执行结束后，

代码才向下执行并且打印btnSync_Click同步方法 End

 

3、异步调用  ：BeginInvoke 实现委托的异步调用，代码如下。

  #region  委托的异步调用及回调BeginInvoke
        /// <summary>
        /// 1、异步方法执行顺序
        /// 2、异步回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

        private void btn_Async_Click(object sender, EventArgs e)
        {
            Console.WriteLine("btn_Async_Click异步方法  start");
            int P = 0;
            AsyncCallback asyncCallback = t =>    //:t 参数实际上是委托的异步调用BeginInvoke返回的结果作为参数
            { 
                Console.WriteLine("在这里处理异步执行完成之后需要完成的业务操作");
                if (t.IsCompleted) 
                {
                     P=1;
                    Console.WriteLine($"P={P}");
                }
            };

            Action<string> action = this.DoSomething;
           //IAsyncResult tr = action.BeginInvoke("btn_Async_Click", new AsyncCallback(UpdateInstanceP), null);
            action.BeginInvoke("btn_Async_Click", asyncCallback, null);  //:lambala表达式方式
            Console.WriteLine("btn_Async_Click异步方法  End");
        }
        #endregion

我们可以看到，异步方法执行顺序和同步方法不同。异步调用DoSomething方法之后，程序并没有等待方法处理完成，而是跳过等待继续往下执行。

并且我们可以看出回调函数一开始并没有执行，而是在DoSomething方法执行结束后才会执行回调函数。所以最后“变量P的值才被更新为1”。

 

4、以上我们定义的方法都没有返回值。但是当程序希望获取已完成的异步方法的结果时，可以检查BeginInvoke返回的IAsyncResult的IsCompleted属性，或者调用委托的EndInvoke方法来等待委托执行完成。 1 /// <summary>

        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAsyn_WithReturn_Click(object sender, EventArgs e)
        {

            #region  判断加EndInvoke方式
            Stopwatch watchStop = new Stopwatch();
            watchStop.Start();
            Func<string,long> func =this.ReturnResult;
            IAsyncResult tr= func.BeginInvoke("",null,null);
            while (!tr.IsCompleted)
            {
                Thread.Sleep(200);  //:优点：1、边等待边操作，比如用户提示      2、不足点：可能存在误差，最多200ms
            }
　             //tr.AsyncWaitHandle.WaitOne();  //:优点：1、等到异步完成，没有损耗   2、不足：没办法做提示
              //tr.AsyncWaitHandle.WaitOne(2000);  //:优点：1、最多等待2000ms,可以做超时处理

            long result = func.EndInvoke(tr);
            Console.WriteLine( $"异步方法返回的结果值{result}");
            watchStop.Stop();
            Console.WriteLine("The second RunTime------watchStop-----:{0}", watchStop.ElapsedMilliseconds);
            #endregion


            #region  EndInvoke方式
            Stopwatch watchStop1 = new Stopwatch();
            watchStop1.Start();
            Func<string, long> func1 = this.ReturnResult;
            IAsyncResult tr1 = func1.BeginInvoke("", null, null);
            long result1 = func1.EndInvoke(tr1);
            Console.WriteLine($"异步方法返回的结果值{result1}");
            watchStop1.Stop();
            Console.WriteLine("The second RunTime1-----------watchStop1----------:{0}", watchStop1.ElapsedMilliseconds);
            #endregion


            #region 回调方式获取结果
            Stopwatch watchStop2 = new Stopwatch();
            watchStop2.Start();
            AsyncCallback asyncCallback = t =>
            {
                AsyncResult ar = (AsyncResult)t;
                Func<string, long> del = (Func<string, long>)ar.AsyncDelegate;
                //回调方法中调用了EndInvoke
                long result3 = del.EndInvoke(t);
                Console.WriteLine($"异步方法返回的结果值{result3}");
                watchStop2.Stop();
                Console.WriteLine("The second RunTime1-----------watchStop2----------:{0}", watchStop2.ElapsedMilliseconds);
            };

            Func<string, long> func2 = this.ReturnResult;
            IAsyncResult tr2 = func2.BeginInvoke("", asyncCallback, null);
            #endregion
        }

以下是执行结果。

5、总结

1、多播委托不能异步调用BeginInvoke 

2、BeginInvoke 第三个参数，传递之后可以在回调函数 通过AsyncState属性获取，如下图所示。