《C#本质论》读书笔记（12）委托和Lambda表达式

12.1.2 委托的数据类型

为了减少重复代码数量，可以将比较方法作为参数传递给 BubbleSort（）方法。此外，为了将方法作为参数传递，必须有一个能够标识方法的数据类型——也就是委托。这里的委托类型是 ComparisonHandler 。

 c# 2.0之前的写法

1. class DelegateSample
2. {
3. static void Main(string[] args)
4. {
5. //int[] arr = { 10, 20, 30, 40, 50 };
6. int[] arr = { 50, 40, 30, 20, 10 };
7. ConsoleArr(arr);
8. ComparisonHandler wx = new ComparisonHandler(DelegateSample.IsTrue);
9. BubbleSort(arr, wx);
10.       //C#2.0之前是这么写的
11.       //BubbleSort(arr, new ComparisonHandler(IsTrue));  
12. ConsoleArr(arr);
13. Console.Read();
14. }
15. public delegate bool ComparisonHandler(int a, int b);
16. public static bool IsTrue(int a, int b)
17. {
18. return a > b;
19. }
20. public static void BubbleSort(int[] items, ComparisonHandler comparisonMethod)
21. {
22. int i;
23. int j;
24. int temp;
25. if (items == null)
26. {
27. return;
28. }
29. if (comparisonMethod == null)
30. {
31. throw new ArgumentNullException("comparisonMethod");
32. }
33. for (i = items.Length - 1; i >= 0; i--)
34. {
35. for (j = 1; j <= i; j++)
36. {
37. if (comparisonMethod(items[j - 1], items[j]))
38. {
39. temp = items[j - 1];
40. items[j - 1] = items[j];
41. items[j] = temp;
42. }
43. }
44. }
45. }
46. public static void ConsoleArr(int[] arr)
47. {
48. foreach (var item in arr)
49. {
50. Console.Write(item+",");
51. }
52. Console.WriteLine();
53. }
54. }

C#2.0以后可以直接调用方法

1. public static bool AlphabeticalIsTrue(int a,int b)
2. {
3. int comparison;
4. comparison = (a.ToString().CompareTo(b.ToString()));
5. return comparison > 0;
6. }
7. //C# 2.0以后直接传递方法
8. BubbleSort(arr, AlphabeticalIsTrue);

12.1.3 委托内部机制

第一个属性属于 System.Reflection.MethodiInfo 类型，MethodInfo 定义一个特定方法的签名，其中包括方法的名称、参数和返回类型。除了 MethodInfo，委托还需要一个对象实例，其中包含了要调用的方法。这正式第二个属性 Target 的用途。在静态方法的情况下，Target 对应于类型自身。

1. // 摘要:
2. //     初始化一个委托，该委托对指定的类实例调用指定的实例方法。
3. //
4. // 参数:
5. //   target:
6. //     类实例，委托对其调用 method。
7. //
8. //   method:
9. //     委托表示的实例方法的名称。
10. //
11. // 异常:
12. //   System.ArgumentNullException:
13. //     target 为 null。 - 或 - method 为 null。
14. //
15. //   System.ArgumentException:
16. //     绑定到目标方法时出错。
17. [SecuritySafeCritical]
18. protected Delegate(object target, string method);
19. //
20. // 摘要:
21. //     初始化一个委托，该委托从指定的类调用指定的静态方法。
22. //
23. // 参数:
24. //   target:
25. //     System.Type，它表示定义 method 的类。
26. //
27. //   method:
28. //     委托表示的静态方法的名称。
29. //
30. // 异常:
31. //   System.ArgumentNullException:
32. //     target 为 null。 - 或 - method 为 null。
33. //
34. //   System.ArgumentException:
35. //     target 不是 RuntimeType。 请参见 反射中的运行时类型。 - 或 - target 表示开放式泛型类型。
36. [SecuritySafeCritical]
37. protected Delegate(Type target, string method);

1. class Program
2. {
3. public delegate bool ComparisonHandler(int a, int b);
4. static void Main(string[] args)
5. {
6. int i;
7. int[] items = new int[5];
8. ComparisonHandler comparionMethod;
9. for (i = 0; i < items.Length; i++)
10. {
11. Console.WriteLine("Enter an integer:");
12. items[i] = int.Parse(Console.ReadLine());
13. }
14. comparionMethod = delegate(int first, int second)
15. {
16. return first < second;
17. };
18. BubbleSort(items, comparionMethod);
19. for ( i = 0; i < items.Length; i++)
20. {
21. Console.WriteLine(items[i]);
22. }
23. Console.Read();
24. }
25. public static void BubbleSort(int[] items, ComparisonHandler comparisonMethod)
26. {
27. int i;
28. int j;
29. int temp;
30. if (items == null)
31. {
32. return;
33. }
34. if (comparisonMethod == null)
35. {
36. throw new ArgumentNullException("comparisonMethod");
37. }
38. for (i = items.Length - 1; i >= 0; i--)
39. {
40. for (j = 1; j <= i; j++)
41. {
42. if (comparisonMethod(items[j - 1], items[j]))
43. {
44. temp = items[j - 1];
45. items[j - 1] = items[j];
46. items[j] = temp;
47. }
48. }
49. }
50. }
51. }

在.NET3.5（C# 3.0）中，存在一系列名为“Action”和“Func”的泛型委托。

System.Func 代表有返回类型的委托，而 System.Action 代表无返回类型的委托。

.NET 委托类型不具备结构的相等性（structural equality）。不能将某个委托类型对象引用转换为不相关的委托类型，即使这两个委托类型的形参和返回类型完全一致。例如，这里就不能将 ComparisonHandler 引用直接赋给一个Func<int,int,bool>变量。

遗憾的是，需要结构一致但不相关的委托类型的情况下，为了使用给定的委托，唯一的办法是创建一个新委托。让它引用旧委托的 Invoke 方法。假定有一个 ComparisonHandler 变量 c,需要把 c 赋值给 Func<int,int,bool>类型的变量 f ，那么可以写成 f = c.Invoke;。

1.无参数的语句

即使无参数的语句lambda（代表无输入参数的委托），也要输入一对空白的圆括号

1. static void Main(string[] args)
2. {
3. //...
4. Func<string> getUserInput =
5. () =>
6. {
7. string input;
8. do
9. {
10. input = Console.ReadLine();
11. }
12. while (input.Trim().Length == 0);
13. return input;
14. };
15. //...
16. }

圆括号规则的一个例外是，当编译器能推断出数据类型，而且只有一个参数的时候。语句Lambda可以不带圆括号。

2.只有一个参数的语句

1. IEnumerable<Process> processes = Process.GetProcesses()
2. .Where(process => { return process.WorkingSet64 > 100000000; });

Where() 返回的是对物理内存占用超过 1GB 的进程的一个查询

语句Lambda含有一个语句块，所以可以包含零个或者更多的语句，

表达式Lambda比语句Lambda更进一步。语句Lambda的代码块都只由一个return语句构成。其实在这种lambda块中，唯一需要就是准备返回的表达式。其他可以省略。

使用一个表达式Lambda来传递委托

1. BubbleSort(items, (first, second) => first > second);

来自为知笔记(Wiz)