委托与Lambda表达式
1、委托概述
2、匿名方法
3、语句Lambda
4、表达式Lambda
5、表达式树
一、委托概述
相当于C++当中的方法指针，在C#中使用delegate 委托来提供相同的功能，
它将方法作为对象封装起来，允许在"运行时"间接地绑定一个方法调用。
声明的委托相当于一种自定义的数据类型。
1、背景
冒泡排序
static class SimpleSort1
{
public static void BubbleSort(int[] items)
{
int i = , j = , temp = ;
if (items == null)
{
return;
}
for (i = items.Length - ; i >= ; i--)
{
for (j = ; j <= i; j++)
{
if (items[j - ] > items[i])
{
temp = items[j - ];
items[j - ] = items[i];
items[i] = temp;
}
} }
}
}
如果需要提供升序和降序两个功能选择，可以加上参数SortType来区别
class Program
{
static void Main(string[] args)
{ int[] arr = new int[] { , , , , , , , , , , , };
SimpleSort1.BubbleSort(arr, SortType.Ascending);
string str = "";
for (int i = ; i < arr.Length; i++)
{
str += arr[i] + ","; }
Console.WriteLine(str); str = "";
SimpleSort1.BubbleSort(arr, SortType.Descending);
for (int i = ; i < arr.Length; i++)
{
str += arr[i] + ","; }
Console.WriteLine(str);
Console.ReadLine(); }
}
enum SortType
{
Ascending,
Descending
}
static class SimpleSort1
{
public static void BubbleSort(int[] items, SortType sorttype)
{
int i = , j = , temp = ;
if (items == null)
{
return;
}
for (i = items.Length - ; i >= ; i--)
{
for (j = ; j <= i; j++)
{
switch (sorttype)
{
case SortType.Ascending:
if (items[j - ] > items[i])
{
temp = items[j - ];
items[j - ] = items[i];
items[i] = temp;
}
break;
case SortType.Descending:
if (items[j - ] < items[i])
{
temp = items[j - ];
items[j - ] = items[i];
items[i] = temp;
}
break; } } } }
}
如果想要按字母、随机或者按照其他方式来排序， 可以通过增加一个SortType参数
BubbleSort()方法及其对应的SortType值的数量很快会变量非常之多。
2、委托数据类型
为了减少重复代码的数量，可以将比较方法作一个参数
传给BubbleSort()方法，此外，为了能将方法作为参数传递，必须要有一个能够
表示方法的数据类型---也就是要有一个委托。
大致使用步骤：声明一个委托数据类型，声明的一个新的委托相当于一个数据类型。
可以用来作为形式参数的类型，在方法调用的时候，赋值一个与此委托相当签名的方法。
3、委托的内部机制
C#将所有委托定义成间接派生于System.Delegate
委托类型的对象模型：待查。
所有委托都是不可变的。更改“委托”要求实例化一个新委托，并在新委托中包含要修改
的地方。
4、委托类型的定义
class DelegateSample
{
public delegate bool ComparisonHandler(int first, int second);
//相当于创建了一个数据类型：DelegateSample.ComparisonHandler
//因为它被定义成嵌套在DelegateSample中的一个类型。 }
虽然所有委托数据类型都间接从System.Delegate派生，但C#编译器并不允许定义一个直接或间接
从System.Delegate派生的类。 class Program
{
static void Main(string[] args)
{ int[] arr = new int[] { , , , , , , , , , , , };
string str = "";
//调用方法时，将指定的函数作为实际参数使用。使用方法来创建一个委托变量，委托是一个引用类型，但不必
//用new来实例化它。直接传递名称，而不是显式实例化，这是自C#2.0开始支持的一个新语法，称为委托推断 delegate interface
//采用这个语法，编译器将根据方法名来查找方法签名，并验证它同方法的参数类型匹配。
SimpleSort1.BubbleSort(arr, SimpleSort1.GreaterThan);
for (int i = ; i < arr.Length; i++)
{
str += arr[i] + ","; }
Console.WriteLine(str); str = "";
SimpleSort1.BubbleSort(arr, SimpleSort1.LonwerThan);
for (int i = ; i < arr.Length; i++)
{
str += arr[i] + ","; }
Console.WriteLine(str); str = "";
SimpleSort1.BubbleSort(arr, SimpleSort1.CharThan);
for (int i = ; i < arr.Length; i++)
{
str += arr[i] + ","; }
Console.WriteLine(str); Console.ReadLine(); }
} static class SimpleSort1
{
//使用委托数据类型 声明一个变量作为形式参数
public static void BubbleSort(int[] items, DelegateSample.ComparisonHandler compareMethod)
{
int i = , j = , temp = ;
if (items == null)
{
return;
}
for (i = items.Length - ; i >= ; i--)
{
for (j = ; j <= i; j++)
{
if (compareMethod(items[j - ], items[i]))
{
temp = items[j - ];
items[j - ] = items[i];
items[i] = temp;
}
}
}
} //以下四个函数都与数据类型DelegateSample.ComparisonHandler(委托) 具有同样的签名
public static bool GreaterThan(int first, int second)
{
return first > second;
}
public static bool LonwerThan(int first, int second)
{
return first < second;
}
public static bool CharThan(int first, int second)
{
int flag = (first.ToString()).CompareTo(second.ToString());
return (flag > ) ? true : false;
}
}
class DelegateSample
{
public delegate bool ComparisonHandler(int first, int second);
//相当于创建了一个数据类型：DelegateSample.ComparisonHandler }
二、匿名方法
C#2.0 和更高的版本还支持不念旧恶名为匿名方法的特性。
所谓匿名方法，就是没有实际方法声明的委托实例。
DelegateSample.ComparisonHandler compareMethod;
compareMethod =
delegate(int first, int second)
{
return first > second;
};
SimpleSort1.BubbleSort(arr, compareMethod);
在这个上下文中，delegate关键字指定了一个“委托字面值“类型，这类似用双引号来指定一个
字符串字面值。
同理可以在不使用compareMethod 变量的前提下直接使用匿名方法当作实际参数来使用。
SimpleSort1.BubbleSort(arr,
delegate(int first, int second)
{
return first > second;
}
);
在任何情况下，匿名方法的参数和返回值类型都必须兼容于相对应的委托类型。
自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);这只是其中的一种
更多可以参考源程序集。
可以如此使用
System.Func<int, int, bool> compareMethodFun;
compareMethodFun =
delegate(int first, int second)
{
return first > second;
};
代码可以不必声明一个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
Action<Object> broadAction = delegate(Object o)
{
Console.WriteLine(o);
};
Action<String> narrowAction = broadAction; Func<string> narrowFunction = delegate()
{
return Console.ReadLine();
}; Func<Object> broadFunction = narrowFunction;
同理，可以in out同时发生。
Func<Object, String> narrowFunction = delegate(Object obj)
{ return obj.ToString();
}; Func<String, Object> broadFunction = narrowFunction;
在这些泛型委托中对协变性和逆变性 的需求是C#现在添加这个功能的一个关键原因。
四、Lambda表达式
C#3.0中引入的Lambda表达式是比匿名方法更加简洁的一种匿名函数语法。
这里的匿名函数泛指Lambda表达式和匿名方法。
Lambda表达式本身划分为两种类型:语句Lambda和表达式Lambda。
与匿名函数有关的术语，待查。
注：所有匿名函数都是不可变的。
1、语句Lambda
语句Lambda是C#3.0为匿名方法提供的一种简化语法。
这种语法不包含delegate关键字，但添加了Lambda运算符 => 。
SimpleSort1.BubbleSort(arr,
(int first, int second) =>
{
//可以有多个语句
return first > second;
}
);
查看含有Lambda运算符的代码时，可以将这个运算符理解成"用于"两字。
如以上则理解为first second用于返回 first>second。
语句Lambda还允许通过"类型参数推断"来进一步简化语法。可以不显式声明参数的
数据类型，只要编译器能推断出类型，语句Lambda就允许省略参数类型。
SimpleSort1.BubbleSort(arr,
(first, second) =>
{
return first > second;
}
);
通常，只要编译器能推断出参数类型，或者能将参数类型隐式转换成期望的类型，语句
Lambda就不需要参数类型。
只要语句Lambda包含了一个类型，所有类型都要加上。
即使是无参数的语句Lambda，也需要输入一对空白的圆括号。
圆括号规则的一个例外是，如果编译器能推断出数据类型，而且只有一个输入参数的时候，语句
Lambda可以不带圆括号。
如：
IEnumerable<Process> processes = Process.GetProcesses().Where(
process => { return process.WorkingSet64 > ( ^ ); });
以上代码返回的是对物理内存占用超过1GB的进程的一个查询。
虽然一个语句Lambda允许包含任意数量的语句，但在它的语句块中，一般只使用两三条语句。
2、表达式Lambda
语句Lambda含有一个语句块，所以可以包含多个语句或者零个语句。
表达式Lambda只有一个表达式，没有语句块。其它一致。
如：
SimpleSort1.BubbleSort(arr, (first, second) => first > second);
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>
会创建表达式树，而不是委托。
System.Linq.Expressions.Expression<Func<int, int, bool>> expression;
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之外的上下文中使用它。