C#中的Predicate 理解 及 delegate 委托

最近学习C#，看到Predicate部分，下面结合自己的理解，大致的讲解一下。如有错误及纰漏之处，还请指正。 

delegate 委托

其实理解起来最相似的就是C/C++里的函数指针了，例如：

[cpp]  view plain copy

1. typedef void mydelegate(char * args);  
2.   
3. void myFunc(char * args){/*...*/};  
4. void myFunc2(mydelegate inFunc,char * args){  
5.     inFunc(args);  
6. }  
7.   
8. int main(){  
9.     mydelegate xx;  
10.     xx=myFunc;  
11.     xx(/*...*/);  
12.     //...  
13. }  

然后我们就可以声明一个签名与mydelegate一致的函数，赋值给xx了，当然，mydelegate也可以作为函数的参数类型。委托就是如此。 但是，事件委托有一个特别地方，那就是它有一个队列，当我们绑定到一个事件时，我们的函数只是加入了这个队列，事件发生时，会按队列顺序依次调用函数，就像HOOK一样。

 

下面参考：http://technet.microsoft.com/zh-cn/library/bfcke1bz

Predicate 在C#中 的声明为

public delegatebool Predicate<in T>(T obj)

可以看出来，Predicate是一个委托类型，而且是一个泛型的委托类型。 

MSDN中提到了这句：

Visual Basic 和 C# 用户不需要显式创建委托，也不需要指定泛型方法的类型参数。编译器会根据您提供的方法参数确定必需的类型。

Predicate是一个特殊的委托，它由C#.net 或VB.net声明（事实上，如同上面的mydelegate，如果不提前声明，.net自己也没法用，就如同API中的CALLBACK等等），我们可以使用这个类型来创建自己的委托。

但是，由于编译器的智能化，我们不需要显式创建这个委托。 

但是本质上，我们仍然可以显式创建，这可以加深理解，代码如下：

 

[csharp]  view plain copy

1. using System;  
2.   
3. public class PredicateTest  
4. {  
5.     public PredicateTest()  
6.     {   
7.     }  
8.     //Predicate委托声明，已经由.Net进行了声明  
9.     //public delegate bool Predicate<in T>(T obj)  
10.   
11.     //测试数组  
12.     int[] myarr = new int[]{ -1, -2, -3, 4, 5, 6, 0 };  
13.           
14.     //函数，将来用于委托,为了能用于Predicate委托，其函数签名必须符合Predicate的签名要求  
15.     bool func(int i)  
16.     {  
17.         return i > 0;  
18.     }  
19.   
20.     //利用带有Predicate类型参数的泛型函数FindAll使用我们的Predicate委托  
21.     int[] getIntBiggerThan01(int[] intArr)  
22.     {  
23.         //显式声明一个Predicate委托  
24.         Predicate<int> mypre = new Predicate<int>(func);  
25.           
26.         //作为参数传进去  
27.         return Array.FindAll(intArr, mypre);  
28.     }  
29.   
30.     //非显式声明，实际上还是声明了，只不过是临时变量  
31.     int[] getIntBiggerThan02(int[] intArr)  
32.     {  
33.         //作为参数传进去  
34.         return Array.FindAll(intArr, new Predicate<int>(func));  
35.     }  
36.   
37.     //直接lamda表达式  
38.     int[] getIntBiggerThan03(int[] intArr)  
39.     {  
40.         //还是作为参数传进去  
41.         return Array.FindAll(intArr, (i) =>{return i > 0;} );  
42.     }  
43.   
44.     public void TestPredicate()   
45.     {  
46.         Console.WriteLine("-------------------------TestPredicate-----------------------");  
47.         Console.WriteLine("---------getIntBiggerThan01--------");  
48.         foreach (int i in getIntBiggerThan01(myarr))  
49.             Console.WriteLine(i.ToString());  
50.         Console.WriteLine("---------getIntBiggerThan02--------");  
51.         foreach (int i in getIntBiggerThan02(myarr))  
52.             Console.WriteLine(i.ToString());  
53.         Console.WriteLine("---------getIntBiggerThan03--------");  
54.         foreach (int i in getIntBiggerThan03(myarr))  
55.             Console.WriteLine(i.ToString());  
56.         Console.ReadKey();  
57.     }  
58. }  
59. 客户端调用代码为  
60. PredicateTest pt = new PredicateTest();  
61. pt.TestPredicate();   

结果：

 转载于http://blog.csdn.net/shamork/article/details/8564764