Delegate、Predicate、Action和Func

写在前面

• Delegate
• Predicate
• Action
• Func
• 逆变和协变

　　先说下什么是委托（Delegate），委托在C#中是一种类型，和Class是一个级别，但是我们经常把它看做是一个方法。为什么是方法？准确的说应该是回调函数，在C运行时的qsort函数获取指向一个回调函数的指针，以便对数组中的元素进行排序。C#中提供了一种机制，就是委托，一种回调函数的机制。

　　在我们做项目的过程中，委托用到的地方很多，像线程中修改窗体的状态、窗体控件事件和异步操作已完成等，以前我们创建委托的时候用delegate关键字，而且也比较麻烦，自从C#4.0有了泛型，也就有了泛型委托，使用Predicate、Action和Func我们可以更好的创建委托。

Delegate

　　我们以前定义一个委托可以这样：

 1         delegate Boolean delgate1(int item);
 2         public void delgateCommon()
 3         {
 4             var d1 = new delgate1(delegateMethod1);
 5             if (d1(1))
 6             {
 7 
 8             }
 9         }
10         static bool delegateMethod1(int item)
11         {
12             return false;
13         }

　　通过上面简单的示例可以看到，先创建一个delgate1的委托类型，参数类型是int，返回值时bool，下面定义一个静态方法delegateMethod1，创建一个delgate1类型的实例，参数为delegateMethod1方法名，这个也成为订阅或是注册，为这个委托类型注册一个回调方法，下面就是调用了，我们在C#创建调用一个委托就是这么简单，其实是很复杂的，只不过这些工作是编译器帮我们做了。

　　需要注意的是上面定义的回调方法是静态（static），如果我们创建的不是静态方法，也是可以，只不过调用的时候需要实例访问。

　　静态方法都是通过关键字static来定义的，静态方法不需要实例这个对象就可以通过类名来访问这个对象。在静态方法中不能直接访问类中的非静态成员。而用实例方法则需要通过具体的实例对象来调用，并且可以访问实例对象中的任何成员。如果用委托绑定实例方法的话需要用实例对象来访问，所以我们在绑定实例方法到委托的时 候必须同时让委托得到实例对象的信息，这样才能在委托被回调的时候成功执行这个实例方法。也就是说，当绑定实例方法给委托的时候，参数会被设置为这个参数所在类型的实例对象。如果给委托绑定的是静态方法，那么这个参数将被设置为NULL。

　　综上，委托既可以绑定静态方法也可以绑定实例方法，但是在绑定实例方法的时候，delegate的target属性就被设置为指向这个实例方法所属类型的一个实例对象。当绑定静态方法时，delegate的target属性就给NULL。

　　废话说的有点多，下面我们看下C#泛型委托，和结合一些匿名函数，lambda表达式的应用，其实就是一些特殊的委托。

Predicate

 1     // 摘要:
 2     //     表示定义一组条件并确定指定对象是否符合这些条件的方法。
 3     //
 4     // 参数:
 5     //   obj:
 6     //     要按照由此委托表示的方法中定义的条件进行比较的对象。
 7     //
 8     // 类型参数:
 9     //   T:
10     //     要比较的对象的类型。
11     //
12     // 返回结果:
13     //     如果 obj 符合由此委托表示的方法中定义的条件，则为 true；否则为 false。
14     public delegate bool Predicate<in T>(T obj);

　　可以看到Predicate的签名是一个泛型参数，返回值是bool。需要注意的是T前面的in表示什么意思？请点这里。代码可以这样写：

 1         public void delgatePredicate()
 2         {
 3             var d1 = new Predicate<int>(delegateMethod2);
 4             if (d1(1))
 5             {
 6 
 7             }
 8         }
 9         static bool delegateMethod2(int item)
10         {
11             return false;
12         }

　　可以看到使用Predicate创建委托简化了好多，我们可以自定义参数，但是只能有一个，而且返回值必须是bool类型，是不是感觉限制太多了？无返回值或是多个参数怎么办？请看下面。

Action

 1     // 摘要:
 2     //     封装一个方法，该方法具有两个参数并且不返回值。
 3     //
 4     // 参数:
 5     //   arg1:
 6     //     此委托封装的方法的第一个参数。
 7     //
 8     //   arg2:
 9     //     此委托封装的方法的第二个参数。
10     //
11     // 类型参数:
12     //   T1:
13     //     此委托封装的方法的第一个参数类型。
14     //
15     //   T2:
16     //     此委托封装的方法的第二个参数类型。
17     [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
18     public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);

　　上面是Action两个泛型参数的签名，最多支持十六个泛型参数，可以看到Action无返回值，创建代码如下：

 1         public void delgateAction()
 2         {
 3             var d1 = new Action<int>(delegateMethod3);
 4             var d2 = new Action<int, string>(delegateMethod4);
 5             d1(1);
 6             d2(1, "");
 7         }
 8         static void delegateMethod3(int item)
 9         {
10         }
11         static void delegateMethod4(int item, string str)
12         {
13         }

　　如果我们想创建的委托类型是有多个参数，而且必须要有返回值，我们怎么办？请看下面。

Func

 1     // 摘要:
 2     //     封装一个具有两个参数并返回 TResult 参数指定的类型值的方法。
 3     //
 4     // 参数:
 5     //   arg1:
 6     //     此委托封装的方法的第一个参数。
 7     //
 8     //   arg2:
 9     //     此委托封装的方法的第二个参数。
10     //
11     // 类型参数:
12     //   T1:
13     //     此委托封装的方法的第一个参数类型。
14     //
15     //   T2:
16     //     此委托封装的方法的第二个参数类型。
17     //
18     //   TResult:
19     //     此委托封装的方法的返回值类型。
20     //
21     // 返回结果:
22     //     此委托封装的方法的返回值。
23     [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
24     public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);

　　上面是Func两个参数，一个返回值的签名，和Action一样最多支持十六个返回值，唯一的区别是Func支持自定义返回值类型，也可以看到T1、T2前修饰符是in，TResult前的修饰符是out，这个下面有说明。创建调用代码：

 1         public void delgateFunc()
 2         {
 3             string hiddenMethodString = "";
 4             var d1 = new Func<int, bool>(delegateMethod5);
 5             var d2 = new Func<int, string, string>(delegate(int item, string str)
 6                 {
 7                     return hiddenMethodString;//匿名方法，好处：可读性更好，可以访问当前上下文
 8                 });
 9             var d3 = new Func<string, string>((a) => {
10                 return a;//lambda表达式，a作为参数，自动判断类型，如果单条语句，省略{}
11             });
12             d1(1);
13             d2(1, "");
14             d3("");
15         }
16         static bool delegateMethod5(int item)
17         {
18             return true;
19         }

　　上面的代码中我们使用和匿名方法和lambda表达式，可以看出其中的好处，省略创建方法的过程，代码更简洁，在Func中使用lambda表达式是很常见的，匿名方法有个好处就是可以访问上下文中的变量，比如hiddenMethodString，关于匿名方法和lambda表达式在这就不做解读了，其实就是一种语法规范，随着C#的发展，也不断在发展变化中。

　　完整示例代码：

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace Predicate_Action_Func
 7 {
 8     class Program
 9     {
10         static void Main(string[] args)
11         {
12             delgateCommon();
13         }
14 
15         #region 常规委托
16         delegate Boolean delgate1(int item);
17         public void delgateCommon()
18         {
19             var d1 = new delgate1(delegateMethod1);
20             if (d1(1))
21             {
22                 Console.WriteLine("111");
23             }
24         }
25         bool delegateMethod1(int item)
26         {
27             return true;
28         }
29         #endregion
30 
31         #region Predicate委托-自定义参数（参数只能一个）
32         public void delgatePredicate()
33         {
34             var d1 = new Predicate<int>(delegateMethod2);
35             if (d1(1))
36             {
37 
38             }
39         }
40         static bool delegateMethod2(int item)
41         {
42             return false;
43         }
44         #endregion
45 
46         #region Action委托-自定义参数（参数为多个，多类型，但无返回值）
47         public void delgateAction()
48         {
49             var d1 = new Action<int>(delegateMethod3);
50             var d2 = new Action<int, string>(delegateMethod4);
51             d1(1);
52             d2(1, "");
53         }
54         static void delegateMethod3(int item)
55         {
56         }
57         static void delegateMethod4(int item, string str)
58         {
59         }
60         #endregion
61 
62         #region Func委托-自定义参数（参数为多个，多类型，但有返回值）
63         public void delgateFunc()
64         {
65             string hiddenMethodString = "";
66             var d1 = new Func<int, bool>(delegateMethod5);
67             var d2 = new Func<int, string, string>(delegate(int item, string str)
68                 {
69                     return hiddenMethodString;//匿名方法，好处：可读性更好，可以访问当前上下文
70                 });
71             var d3 = new Func<string, string>((a) => {
72                 return a;//lambda表达式，a作为参数，自动判断类型，如果单条语句，省略{}
73             });
74             d1(1);
75             d2(1, "");
76             d3("");
77         }
78         static bool delegateMethod5(int item)
79         {
80             return true;
81         }
82         #endregion
83     }
84 }

View Code

逆变和协变

什么是逆变性、协变性？

　　我们这样创建和调用委托：

 1         delegate object delgate1(FieldAccessException item);
 2         public void delgateCommon()
 3         {
 4             var d1 = new delgate1(delegateMethod1);
 5             Console.WriteLine(d1(new FieldAccessException()));
 6         }
 7         static string delegateMethod1(Exception item)
 8         {
 9             return "123";
10         }

　　可以看出有些不同了，参数和返回类型不一致，delegateMethod1的参数类型（Exception）是委托的参数类型（FieldAccessException）的基类，delegateMethod1的返回类型（String）派生自委托的返回类型（Object），这种就是逆变和协变，编译和运行是可以的，也就是说是被允许的，逆变和协变只能用于引用类型，不用用于值类型或void。

　　逆变性：方法获取的参数可以是委托的参数类型的基类。

• 泛型类型参数可以从基类型更改为该类的派生类型
• 用in关键字标记逆变形式的类型参数
• 这个参数一般作输入参数，这个在Predicate、Action中有所体现

　　协变性：方法能返回从委托的返回类型派生的一个类型。

• 泛型类型参数可以从派生类型更改为它的基类型
• 用out关键字来标记协变形式的类型参数
• 这个参数一般作为返回值，这个在Func的TResult返回参数有所体现

　　可能有点晕，只要记住逆变是指参数，协变是指返回值；逆变是指基类到派生类，协变是指派生类到基类。

怎么用逆变，协变？

　　泛型委托Predicate、Action和Func都用到了逆变和协变，我们也可以不使用它们自定义一种泛型委托，如下：

 1         delegate TResult MyDelegate<in T,out TResult>(T obj);
 2         public void delgateZidingyi()
 3         {
 4             var d1 = new MyDelegate<FieldAccessException, object>(delegateMethod6);
 5             d1(new FieldAccessException());
 6         }
 7         static string delegateMethod6(Exception item)
 8         {
 9             return "123";
10         }

　　其实上面定义的委托类型MyDelegate，也不需要创建那么麻烦，使用Func就可以了，也从中看出泛型委托Predicate、Action和Func只是微软方便我们创建委托提供的一种方式，我们完全可以自定义，上面也说明了逆变和协变所起到的效果。

　　如果你觉得本篇文章对你有所帮助，请点击右下部“推荐”，^_^