C# Task中的Func, Action, Async与Await的使用

在说Asnc和Await以前,先说明一下Func和Action委托, Task任务的基础的用法

1. Func

Func是一种委托，这是在3.5里面新增的，2.0里面咱们使用委托是用Delegate，Func位于System.Core命名空间下，使用委托能够提高效率，例如在反射中使用就能够弥补反射所损失的性能。

Action<T>和Func<T,TResult>的功能是同样的，只是Action<T>没有返类型，

Func<T,T,Result>：有参数，有返回类型
Action，则既没有返回也没有参数，

Func<T,TResult>
的表现形式分为如下几种：

1。Func<T,TResult>
2。Func<T，T1,TResult>
3。Func<T,T1,T2,TResult>
4。Func<T,T1,T2,T3,TResult>
5。Func<T,T1,T2,T3,T4,TResult>

分别说一下各个参数的意义，TResult表示
委托所返回值 所表明的类型， T,T1,T2,T3,T4表示委托所调用的方法的参数类型，

如下是使用示例：

 1 Func<int, bool> myFunc = null;//所有变量
 2 
 3 myFunc = x => CheckIsInt32(x); 
 4 //给委托封装方法的地方 使用了Lambda表达式
 5 
 6 private bool CheckIsInt32(int pars)//被封装的方法
 7 {
 8 　　return pars == 5;
 9 }
10 
11 bool ok = myFunc(5);//调用委托

MSDN：http://msdn.microsoft.com/zh-cn/library/bb534303(VS.95).aspx

2. Action

可是若是咱们须要所封装的方法不返回值，增么办呢？就使用Action！

可使用
Action<T1, T2, T3, T4>委托以参数形式传递方法，而不用显式声明自定义的委托。封装的方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具备四个均经过值传递给它的参数，而且不能返回值。（在 C# 中，该方法必须返回 void。在 Visual Basic 中，必须经过 Sub…End Sub 结构来定义它。）一般，这种方法用于执行某个操做。

使用方法和Func相似！

Action：既没有返回，也没有参数，使用方式以下：

1 Action action = null;//定义action
2 
3 action =  CheckIsVoid;//封装方法，只须要方法的名字
4 
5 action();//调用

 

MSDN:http://msdn.microsoft.com/zh-cn/library/bb548654(VS.95).aspx

总结：

使用Func<T,TResult>和Action<T>,Action而不使用Delegate其实都是为了简化代码,使用更少的代码达到相同的效果，不须要咱们显示的声明一个委托。

Func<T,TResult>的最后一个参数始终是返回类型，而Action<T>是没有返回类型的，而Action是没有返回类型和参数输入的.

 

3. Task

使用 Async 和 Await 的异步编程(msdn的好文章) :  https://msdn.microsoft.com/zh-cn/library/hh191443(v=vs.120)

Task基本使用: C# 线程知识--使用Task执行异步操做

Task和await结合返回值见: .NET(C#)：await返回Task的async方法

Task深刻了解见: C# Task的使用

 

总结: Task提供一种新的相似多线程的多任务的用法, 达到使用线程的效果,但具体怎么分配线程由.net底层控制,这样性能好,效率也高,咱们只须要专一业务逻辑, 同时具有之前线程不具有的返回值的功能(能够经过回调事件来处理),而在Task中只是简单的使用await来使用, await的task至关于同步的调用task, 同时会有返回值,只是在书写方面须要注意async, task,func, action等等关键字的使用,新手可能很困惑, 下面的例子就是一个简单的task使用例子,新手注意注释!!!

 1 static void Main(string[] args)
 2 {
 3     //异步方法, 当中使用await能够执行task异步任务,不然看成同步执行
 4     test();
 5     //其次输出,由于异步进入task任务了,就同步执行当前线程下面的代码
 6     log("Main：调用test后");
 7     Thread.Sleep(Timeout.Infinite); 
 8 }
 9 
10 //Main方法不容许加async，因此咱们用这个方法使用await
11 static async void test()
12 {
13     //最早输出,尚未进入task
14     log("test: await以前");
15     // await后的内容会被加在目标doo的Task的后面，而后test立刻返回,而doo则是进入了另外一个任务执行了
16     log("doo的Task的结果: " + await doo());
17     // 会等到上面await执行的任务完成后才会执行当前代码
18     log("test: await以后");
19 }
20 //返回Task的async方法, 一个标准的带返回值的异步task任务方法
21 static async Task<int> doo()
22 {
23     // 简单的说, async中使用await就是异步中以同步方式执行Task任务的方法,task任务一个接一个执行.
24     var res1 = await Task.Run(() => { Thread.Sleep(1000); log("Awaited Task1 执行"); return 1; });
25     var res2 = await Task.Run(() => { Thread.Sleep(1000); log("Awaited Task2 执行"); return 2; });
26     var res3 = await Task.Run(() => { Thread.Sleep(1000); log("Awaited Task3 执行"); return 3; });
27 
28     //不使用await：线程池多线程, 当前task不会等这个执行完,由于不是await,只是又开启了一个线程
29     ThreadPool.QueueUserWorkItem(_ =>
30     {
31         Thread.Sleep(1000);
32         log("ThreadPool.QueueUserWorkItem: 线程池多线程执行");
33     });
34 
35     //不使用await：Task多线程, 当前task不会等这个执行完,由于不是await,只是又开启了一个任务
36     Task.Run(() =>
37     {
38         Thread.Sleep(1000);
39         log("Task.Run: Task多线程执行");
40 
41     });
42 　　　
43     return res1 + res2 + res3;
44 }
45 //输出方法：显示当前线程号和输出信息
46 static void log(string msg)
47 {
48     Console.WriteLine("线程{0}: {1}", Thread.CurrentThread.ManagedThreadId, msg);
49 }

 

执行结果以下:

 

4. Async、Await

这个是.NET 4.5的特性，因此要求最低.NET版本为4.5。

看不少朋友仍是使用的Thread来使用异步多线程操做，基本上看不见有使用Async、Await进行异步编程的。各有所爱吧，其实均可以。只要正确使用就行，不过仍是写了这篇文章推荐你们使用Async、Await。 缘由就是：能够跟写同步方法同样去异步编程。代码则就很是的清晰，就跟写普通的代码同样，不用关系如何去异步编程，也让不少初级程序员也可以异步编程了。下面是一个使用Thread 多线程实现的异步例子，以及一个使用Async与Await的异步例子，接下来咱们再简单理解下Async与Await的相关技术说明。

Thread多线程异步编程例子

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("主线程测试开始..");
        Thread th = new Thread(ThMethod);
        th.Start();
        Thread.Sleep(1000);
        Console.WriteLine("主线程测试结束..");
        Console.ReadLine();
    }
 
 
    static void ThMethod()
    {
        Console.WriteLine("异步执行开始");
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("异步执行" + i.ToString() + "..");
            Thread.Sleep(1000);
        }
        Console.WriteLine("异步执行完成");
    }
}

 

　　

以上代码运行效果以下图

 

 

使用Async与Await进行异步编程

 

 1 static void Main(string[] args)
 2 {
 3     Console.WriteLine("主线程测试开始..");
 4     AsyncMethod();
 5     Thread.Sleep(1000);
 6     Console.WriteLine("主线程测试结束..");
 7     Console.ReadLine();
 8 }
 9 
10 static async void AsyncMethod()
11 {
12     Console.WriteLine("开始异步代码");
13     var result = await MyMethod();
14     Console.WriteLine("异步代码执行完毕" + result.ToString());
15 }
16 
17 static async Task<int> MyMethod()
18 {
19     for (int i = 0; i < 5; i++)
20     {
21         Console.WriteLine("异步执行" + i.ToString() + "..");
22         await Task.Delay(1000); //模拟耗时操做
23     }
24     return 100;
25 }

 

运行效果：

 

显而易见咱们就跟写同步方法同样，完成了异步方法的编写，代码更清晰了。

只有拥有async才能在其内部使用await关键字。异步方法能够具备Task、Task<>或void的返回类型；

await关键字则是用于返回值是“可等待”类型(awaitable)的方法