委托与Lambda表达式
1、委托概述
2、匿名方法
3、语句Lambda
4、表达式Lambda
5、表达式树
一、委托概述
相当于C++当中的方法指针，在C#中使用delegate 委托来提供相同的功能，
它将方法作为对象封装起来，允许在"运行时"间接地绑定一个方法调用。
声明的委托相当于一种自定义的数据类型。
1、背景
冒泡排序
1 static class SimpleSort1 2 { 3 public static void BubbleSort(int[] items) 4 { 5 int i = 0, j = 0, temp = 0; 6 if (items == null) 7 { 8 return; 9 } 10 for (i = items.Length - 1; i >= 0; i--) 11 { 12 for (j = 1; j <= i; j++) 13 { 14 if (items[j - 1] > items[i]) 15 { 16 temp = items[j - 1]; 17 items[j - 1] = items[i]; 18 items[i] = temp; 19 } 20 } 21 22 } 23 } 24 }
如果需要提供升序和降序两个功能选择，可以加上参数SortType来区别
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 6 int[] arr = new int[] { 1, 2, 5, 645, 4, 6, 73, 5, 3, 6, 7, 66 }; 7 SimpleSort1.BubbleSort(arr, SortType.Ascending); 8 string str = ""; 9 for (int i = 0; i < arr.Length; i++) 10 { 11 str += arr[i] + ","; 12 13 } 14 Console.WriteLine(str); 15 16 str = ""; 17 SimpleSort1.BubbleSort(arr, SortType.Descending); 18 for (int i = 0; i < arr.Length; i++) 19 { 20 str += arr[i] + ","; 21 22 } 23 Console.WriteLine(str); 24 Console.ReadLine(); 25 26 } 27 } 28 enum SortType 29 { 30 Ascending, 31 Descending 32 } 33 static class SimpleSort1 34 { 35 public static void BubbleSort(int[] items, SortType sorttype) 36 { 37 int i = 0, j = 0, temp = 0; 38 if (items == null) 39 { 40 return; 41 } 42 for (i = items.Length - 1; i >= 0; i--) 43 { 44 for (j = 1; j <= i; j++) 45 { 46 switch (sorttype) 47 { 48 case SortType.Ascending: 49 if (items[j - 1] > items[i]) 50 { 51 temp = items[j - 1]; 52 items[j - 1] = items[i]; 53 items[i] = temp; 54 } 55 break; 56 case SortType.Descending: 57 if (items[j - 1] < items[i]) 58 { 59 temp = items[j - 1]; 60 items[j - 1] = items[i]; 61 items[i] = temp; 62 } 63 break; 64 65 } 66 67 } 68 69 } 70 71 72 } 73 } 74
如果想要按字母、随机或者按照其他方式来排序， 可以通过增加一个SortType参数
BubbleSort()方法及其对应的SortType值的数量很快会变量非常之多。
2、委托数据类型
为了减少重复代码的数量，可以将比较方法作一个参数
传给BubbleSort()方法，此外，为了能将方法作为参数传递，必须要有一个能够
表示方法的数据类型---也就是要有一个委托。
大致使用步骤：声明一个委托数据类型，声明的一个新的委托相当于一个数据类型。
可以用来作为形式参数的类型，在方法调用的时候，赋值一个与此委托相当签名的方法。
3、委托的内部机制
C#将所有委托定义成间接派生于System.Delegate
委托类型的对象模型：待查。
所有委托都是不可变的。更改“委托”要求实例化一个新委托，并在新委托中包含要修改
的地方。
4、委托类型的定义
1 class DelegateSample 2 { 3 public delegate bool ComparisonHandler(int first, int second); 4 //相当于创建了一个数据类型：DelegateSample.ComparisonHandler 5 //因为它被定义成嵌套在DelegateSample中的一个类型。 6 7 } 8 虽然所有委托数据类型都间接从System.Delegate派生，但C#编译器并不允许定义一个直接或间接 9 从System.Delegate派生的类。 10 11 class Program 12 { 13 static void Main(string[] args) 14 { 15 16 int[] arr = new int[] { 1, 32, 5, 645, 4, 6, 73, 5, 36, 61, 7, 66 }; 17 string str = ""; 18 //调用方法时，将指定的函数作为实际参数使用。使用方法来创建一个委托变量，委托是一个引用类型，但不必 19 //用new来实例化它。直接传递名称，而不是显式实例化，这是自C#2.0开始支持的一个新语法，称为委托推断 delegate interface 20 //采用这个语法，编译器将根据方法名来查找方法签名，并验证它同方法的参数类型匹配。 21 SimpleSort1.BubbleSort(arr, SimpleSort1.GreaterThan); 22 for (int i = 0; i < arr.Length; i++) 23 { 24 str += arr[i] + ","; 25 26 } 27 Console.WriteLine(str); 28 29 str = ""; 30 SimpleSort1.BubbleSort(arr, SimpleSort1.LonwerThan); 31 for (int i = 0; i < arr.Length; i++) 32 { 33 str += arr[i] + ","; 34 35 } 36 Console.WriteLine(str); 37 38 str = ""; 39 SimpleSort1.BubbleSort(arr, SimpleSort1.CharThan); 40 for (int i = 0; i < arr.Length; i++) 41 { 42 str += arr[i] + ","; 43 44 } 45 Console.WriteLine(str); 46 47 Console.ReadLine(); 48 49 50 51 } 52 } 53 54 static class SimpleSort1 55 { 56 //使用委托数据类型 声明一个变量作为形式参数 57 public static void BubbleSort(int[] items, DelegateSample.ComparisonHandler compareMethod) 58 { 59 int i = 0, j = 0, temp = 0; 60 if (items == null) 61 { 62 return; 63 } 64 for (i = items.Length - 1; i >= 0; i--) 65 { 66 for (j = 1; j <= i; j++) 67 { 68 if (compareMethod(items[j - 1], items[i])) 69 { 70 temp = items[j - 1]; 71 items[j - 1] = items[i]; 72 items[i] = temp; 73 } 74 } 75 } 76 } 77 78 79 //以下四个函数都与数据类型DelegateSample.ComparisonHandler(委托) 具有同样的签名 80 public static bool GreaterThan(int first, int second) 81 { 82 return first > second; 83 } 84 public static bool LonwerThan(int first, int second) 85 { 86 return first < second; 87 } 88 public static bool CharThan(int first, int second) 89 { 90 int flag = (first.ToString()).CompareTo(second.ToString()); 91 return (flag > 0) ? true : false; 92 } 93 } 94 class DelegateSample 95 { 96 public delegate bool ComparisonHandler(int first, int second); 97 //相当于创建了一个数据类型：DelegateSample.ComparisonHandler 98 99 }
二、匿名方法
C#2.0 和更高的版本还支持不念旧恶名为匿名方法的特性。
所谓匿名方法，就是没有实际方法声明的委托实例。
1 DelegateSample.ComparisonHandler compareMethod; 2 compareMethod = 3 delegate(int first, int second) 4 { 5 return first > second; 6 }; 7 SimpleSort1.BubbleSort(arr, compareMethod);
在这个上下文中，delegate关键字指定了一个“委托字面值“类型，这类似用双引号来指定一个
字符串字面值。
同理可以在不使用compareMethod 变量的前提下直接使用匿名方法当作实际参数来使用。
1 SimpleSort1.BubbleSort(arr, 2 delegate(int first, int second) 3 { 4 return first > second; 5 } 6 );
自C#2.0开始，可以利用匿名方法这一新特性来声明一个没有名字的方法，该方法将
自动被转换成一个委托。
无参数的匿名方法，可以省略() ，但返回类型仍然需要与委托的返回类型兼容。
三、系统定义的委托：Func<> Action<>
在.NET3.5（C#3.0）中，存在一系列名为Action和Func的泛型委托。(委托模板)
System.Func代表有返回类型的委托，而System.Action代表无返回类型的委托。
这些委托全是泛型的，因此可以直接使用它们而不用自定义一个委托。
如：
系统自带的
public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);这只是其中的一种
更多可以参考源程序集。
可以如此使用
1 System.Func<int, int, bool> compareMethodFun; 2 compareMethodFun = 3 delegate(int first, int second) 4 { 5 return first > second; 6 };
代码可以不必声明一个ComparisonHandler委托类型，而是直接使用Func<int, int, bool> 这个泛型类型委托
来声明一个委托类型的实例。
注：Func的最后一个类型参数总是委托的返回类型，在它之前的类型参数
则依次对应于委托参数的类型。
对于那些没有返回类型而且不接受参数的委托，应该使用System.Action或者某个泛型类型。
比如自定义的委托类型，可以让我们明确知道该委托的用途，相反
Func<int, int, bool> 除了让我们明白方法的签名之外，就不能再提供其他有意义的信息了。
注：这些只有安装.NET3.5的客户端才能使用此功能。
注意，即使可以且一个Func泛型委托来代替一个显式定义的委托，两者的类型也不兼容。
不能将一个委托类型赋给另一个委托类型的变量，即使类型参数匹配。
通过C#4.0 添加的对协变性和逆变性的支持，确实可以在它们之间进行一定程序的转型。
但是，假如代码中使用某个委托类型能使编码变得更简单，那么仍然应该声明委托类型。
如
void Action<in T>(T arg) 有一个in类型的参数修饰符，所以支持逆变性
所以可以将Action<object>类型的一个对象赋给Action<string>类型的一个变量。
同理out
1 Action<Object> broadAction = delegate(Object o) 2 { 3 Console.WriteLine(o); 4 }; 5 Action<String> narrowAction = broadAction; 6 7 Func<string> narrowFunction = delegate() 8 { 9 return Console.ReadLine(); 10 }; 11 12 Func<Object> broadFunction = narrowFunction;
同理，可以in out同时发生。
1 Func<Object, String> narrowFunction = delegate(Object obj) 2 { 3 4 return obj.ToString(); 5 }; 6 7 Func<String, Object> broadFunction = narrowFunction;
在这些泛型委托中对协变性和逆变性 的需求是C#现在添加这个功能的一个关键原因。
四、Lambda表达式
C#3.0中引入的Lambda表达式是比匿名方法更加简洁的一种匿名函数语法。
这里的匿名函数泛指Lambda表达式和匿名方法。
Lambda表达式本身划分为两种类型:语句Lambda和表达式Lambda。
与匿名函数有关的术语，待查。
注：所有匿名函数都是不可变的。
1、语句Lambda
语句Lambda是C#3.0为匿名方法提供的一种简化语法。
这种语法不包含delegate关键字，但添加了Lambda运算符 => 。
1 SimpleSort1.BubbleSort(arr, 2 (int first, int second) => 3 { 4 //可以有多个语句 5 return first > second; 6 } 7 );
查看含有Lambda运算符的代码时，可以将这个运算符理解成"用于"两字。
如以上则理解为first second用于返回 first>second。
语句Lambda还允许通过"类型参数推断"来进一步简化语法。可以不显式声明参数的
数据类型，只要编译器能推断出类型，语句Lambda就允许省略参数类型。
1 SimpleSort1.BubbleSort(arr, 2 (first, second) => 3 { 4 return first > second; 5 } 6 );
通常，只要编译器能推断出参数类型，或者能将参数类型隐式转换成期望的类型，语句
Lambda就不需要参数类型。
只要语句Lambda包含了一个类型，所有类型都要加上。
即使是无参数的语句Lambda，也需要输入一对空白的圆括号。
圆括号规则的一个例外是，如果编译器能推断出数据类型，而且只有一个输入参数的时候，语句
Lambda可以不带圆括号。
如：
1 IEnumerable<Process> processes = Process.GetProcesses().Where( 2 process => { return process.WorkingSet64 > (2 ^ 30); });
以上代码返回的是对物理内存占用超过1GB的进程的一个查询。
虽然一个语句Lambda允许包含任意数量的语句，但在它的语句块中，一般只使用两三条语句。
2、表达式Lambda
语句Lambda含有一个语句块，所以可以包含多个语句或者零个语句。
表达式Lambda只有一个表达式，没有语句块。其它一致。
如：
1 SimpleSort1.BubbleSort(arr, (first, second) => first > second); 2 SimpleSort1.BubbleSort(arr, (int first, int second) => first > second);
语句Lambda和表达式Lambda的区别在于，语句Lambda在Lambda运算符的右侧有一个语句块，用{}包含。
而表达式Lambda只有一个表达式(没有return语句及大括号)。
注：括号及参数类型的省略同语句Lambda
3、Lambda表达式和匿名方法的内部机制
Lambda表达式(和匿名方法)并非CLR内部的固有构造，它们的实现是C#编译器在编译时生成的。
Lambda表达式为“以内嵌方式声明的委托”模式提供了一个对应的C#语言构造。
这样一来，C#编译就会为这个模式生成实现代码。
在CIL中，一个匿名方法被转换成一个单独、由编译器
内部声明的静态方法，这个静态方法再实例化成一个委托，并作为参数传递。
4、外部变量
在Lambda表达式（包括参数）的外部声明，但在Lambda表达式内部访问的局部变量称为该
Lambda表达式的外部变量。
this也是一个外部变量，外部变量被匿名函数捕捉（访问）后，在匿名函数的委托被销毁之前，该
外部变量将一直存在。
被捕捉的变量的生存期至少和捕捉它的最长命的委托对象一样长。
类似闭包。
外部变量的CIL实现 。
被捕捉的局部变量被当作一个实例字段来实现，从而延长了其生命周期。
对局部变量的所有引用都被重新编写成对那个字段的引用。
变量允许在不改变表达式签名的前提下，将数据从表达戒指一次调用传递到下一次调用。
5、表达式树
如果一种Lambda表达式代表的是与表达式有关的数据，而不是编译好的代码，这种Lambda表达式就是
"表达式树"。
1、Lambda表达式作为数据使用
由于表达式树代表的是数据而非编译好的代码，所以可以把数据转换成一种替代格式。
例如，可以把它从表达式数据转换成数据库中执行的SQL代码。
但，表达式树并非只能转换成SQL语句。
2、表达式树作为对象图使用
表达式树转换成的数据是一个对象图，它由System.Linq.Expressions.Expression表示。
3、Lambda表达式和表达式树的比较
在编译时，Lambda表达式在CIL中被编译成一个委托，而表达式树被编译成System.Linq.Expressions.Expression
类型的一个数据结构。
可通过System.Linq.Enumerable 与 System.Linq.Queryable这两个类的进行比较.
它们分别实现了IEnumerable和IQueryable集合接口。例如 Where()。
4、解析表达式树
由于Lambda表达式没有与生俱来的类型，所以将Lambda表达式赋给System.Linq.Expressions.Expression<TDelegate>
会创建表达式树，而不是委托。
1 System.Linq.Expressions.Expression<Func<int, int, bool>> expression; 2 expression = (x, y) => x > y;
表达式树是一个数据集合，而通过遍历数据，就可以将数据转换成另一种格式。
有多个表达式类型，
如：
System.Linq.Expressions.BinaryExpression
System.Linq.Expressions.ConditionalExpression
System.Linq.Expressions.LambdaExpression
System.Linq.Expressions.MethodCallExpression
System.Linq.Expressions.ParameterExpression
System.Linq.Expressions.ConstantExpression
每个类都派生自System.Linq.Expressions.Expression
通常，语句Lambda和表达式Lambda可以互换使用。然则，不能将语句Lambda转换成"表达式树"。
只能使用表达式Lambda语法来表示"表达式树"。
小结：
利用委托，可以传递一组能在不同位置调用的指令，这些指令不是立即调用的，而是在完成编码之后，再在其他位置调用。
C#2.0 中引入了"匿名方法"
C#3.0 中引入了Lambda表达式的概念。
Lambda表达式语法取代(但并非消除)了C#2.0 的匿名语法。
不管哪种语法，程序员都可以利用它们直接将一组指令赋一个变量，而不必显式地定义
一个包含这些指令的方法。
这使得程序员可以在方法内部动态地编写指令----这是一个很强大的概念，
它通过一个称为LINQ（语言集成查询）的API大幅简化了集合编程。
表达式树的概念，描述了它们如何编译成数据来表示一个Lambda表达式，而不是表示委托的具体实现。
利用这一特性，LINQ to SQL 和 LINQ to XML等库能解释表达式树，
并在CIL之外的上下文中使用它。