C# 创建线程的多种方式之异步调用基础知识

创建线程一种简单的方式是委托的异步调用，Delegate类提供了BeginInvoke方法，该方法可以传递委托类型定义的参数(所以BeginInvoke参数数量是可变的)，另外还有2个固定的参数 回调函数委托AsynsCallBack和类型Object(如果不使用可直接赋值为null)。

BeginInvoke() 的返回值为IAsynResult，通过它的IsComplete属性可以判断异步调用是否完成。

1static void Main(string[] args)
2        {
3            Func<int, int> act1 = new Func<int, int>(Calculate);
4            Console.WriteLine("Main Start....");
5            IAsyncResult ar = act1.BeginInvoke(20,null, null);
6            while (!ar.IsCompleted)
7            {
8                Console.WriteLine("Main is waiting");
9                Thread.Sleep(500);
10            }
11            int result = act1.EndInvoke(ar);
12            Console.WriteLine("Result is " + result);
13            Console.ReadLine();
14        }
15
16        private static int Calculate(int total)
17        {
18            int sum = 0;
19            for (int i = 0; i < total;i++ )
20            {
21                sum += i;
22                Thread.Sleep(100);
23            }
24            return sum;
25        }

运行返回结果：

Main Start....
Main is waiting
Main is waiting
Main is waiting
Main is waiting
Main is waiting
Result is 190

事实上，EndInvoke也是会等到异步调用结束，返回结果的。此外，IAsynResult的AsyncWaitHandle属性是WaitHandle类型，利用WaitOne()能够达到上述同样的效果，我觉得有一个好处就是可以利用WaitAll()等待多个异步调用同时完成：

1static void Main(string[] args)
2        {
3            Func<int, int> act1 = new Func<int, int>(Calculate);
4            Func<int, int> act2 = new Func<int, int>(Calculate);
5            Console.WriteLine("Main Start....");
6            IAsyncResult ar1 = act1.BeginInvoke(20,null, null);
7            IAsyncResult ar2 = act2.BeginInvoke(30, null, null);
8            if(WaitHandle.WaitAll(new WaitHandle[]{ar1.AsyncWaitHandle,ar2.AsyncWaitHandle},5000))
9            {
10                Console.WriteLine("Waiting is over");
11                
12            }
13            int result1 = act1.EndInvoke(ar1);
14            int result2 = act2.EndInvoke(ar2);
15            Console.WriteLine("Result1 is {0},Result2 is {1}", result1, result2);
16            Console.ReadLine();
17        }
18
19        private static int Calculate(int total)
20        {
21            int sum = 0;
22            for (int i = 0; i < total;i++ )
23            {
24                sum += i;
25                Thread.Sleep(100);
26            }
27            return sum;
28        }

我声明了act1和act2两个委托对象，并同时进行异步调用，WaitHandle.WaitAll(new WaitHandle[]{ar1.AsyncWaitHandle,ar2.AsyncWaitHandle},5000) 等待同时完成，最后返回结果：

Main Start....
Waiting is over
Result1 is 190,Result2 is 435

 除了以上2种方式返回运行结果，还可以使用AsynsCallBack回调，BeginInvoke()的最后一个参数可以用ar.Asynstate访问，以便在回调函数中使用，例如传递委托实例获取运行结果：

1static void Main(string[] args)
2        {
3            Func<int, int> act1 = new Func<int, int>(Calculate);
4            Console.WriteLine("Main Start....");
5            IAsyncResult ar1 = act1.BeginInvoke(20, new AsyncCallback(CalculateComplete), act1);
6            while(!ar1.IsCompleted){
7                Console.WriteLine("Main is waiting");
8                Thread.Sleep(500);
9            }
10            Console.ReadLine();
11        }
12
13        private static int Calculate(int total)
14        {
15            int sum = 0;
16            for (int i = 0; i < total;i++ )
17            {
18                sum += i;
19                Thread.Sleep(100);
20            }
21            return sum;
22        }
23
24        private static void CalculateComplete(IAsyncResult ar)
25        {
26            Console.WriteLine("Counting is over...........");
27            Func<int, int> act = ar.AsyncState as Func<int, int>;
28            Console.WriteLine("Result is "+act.EndInvoke(ar));
29        }

运行结果：

Main Start....
Main is waiting
Main is waiting
Main is waiting
Main is waiting
Main is waiting
Counting is over...........
Result is 190

回调函数是在委托线程中完成的，还可以使用Lamda表达式，更加简便，传入最后一个参数，因为Lamda表达式可以访问域外变量：

1static void Main(string[] args)
2        {
3            Func<int, int> act1 = new Func<int, int>(Calculate);
4            Console.WriteLine("Main Start....");
5            IAsyncResult ar1 = act1.BeginInvoke(20, ar => { Console.WriteLine("Result is " + act1.EndInvoke(ar)); }, null);
6            while(!ar1.IsCompleted){
7                Console.WriteLine("Main is waiting");
8                Thread.Sleep(500);
9            }
10            Console.ReadLine();
11        }