本文内容
- 引入
- 概述
- 匿名函数
- Lambda 表达式
- 匿名方法
- 参看资料
引入
本文在 VS 2008 环境下，阐述自己对 Lambda 表达式、匿名函数、委托和 LINQ 谈谈自己的理解。我对这个问题的思考，始于以下阶段：
- 毕业刚参加工作时，使用 VS 2005 C#，它还没有 LINQ 特性。那时的主要精力在后台代码，初步掌握了委托、泛型等，以及设计模式，并尝试编写 JavaScript 代码，只是不太重视；
- 之后，尤其是跳槽后，对 JavaScript、jQuery、Ajax 、DOM、HTML、CSS产生了兴趣，发现它们类似 JSON 的书写方式很有意思，那时已经使用 VS 2008，也有这种方式，因此在实际项目中时不时地采用这种方式书写；
- 期间，知道了 LINQ，觉得不错，在很大程度上，接近自然语言，简化了代码逻辑和代码量；
- 但问题是，这种书写方式除了跟之前（VS 2005 前）完全不同外，无论是 JavaScript，还是 C#，这种方式，可以在不定义变量，不定义函数名、形参和返回值类型等情况下使用，的确让人困惑；
- 为了更好的理解这种书写方式，我学习了 JSON 的理论，之后是 Lambda 表达式、LINQ。
往往，当你缺少某方面知识时，对一个问题的理解不可能深入。
概述
我们都知道，定义一个函数，要有名字，也许要有形参列表、返回值类型。即便是现在，也是如此。
而 Lambda 演算（Lambda calculus），告诉程序员们，其实不然，定义函数可以没有名字，没有形参列表，没有返回值类型，什么都没有，只有函数体，一些表达式或是语句（现在知道这是基于 Lambda 的类型推理），这就是匿名函数。
另一方面——委托，委托相当于函数（方法）指针（事件是委托的特例），那么完全可以利用匿名函数简化委托。Lambda 表达式的理论基础是Lambda 演算（Alonzo Church, 1930）。
LINQ 就是基于 Lambda 表达式（匿名函数）、泛型和简化的委托。
本文的重点是从大的方面上了解 Lambda 表达式和其应用，而不是它的语法。
匿名函数
匿名函数是一个“内联（inline）”语句或表达式，可在需要委托类型的任何地方使用。可以使用匿名函数来初始化命名委托，或传递命名委托（而不是命名委托类型）作为方法参数。
有两种匿名函数：
- Lambda 表达式
- 匿名方法
C# 中委托的发展
- C# 1.0 中，通过用其他位置定义的方法显式初始化委托来创建委托的实例。
- C# 2.0 引入了匿名方法（anonymous method）的概念，用匿名方法初始化委托，在委托中执行未命名的内联语句块。
- C# 3.0 引入了 Lambda 表达式，与匿名方法的概念类似，但更具表现力并且更简练。匿名方法和Lambda 表达式统称为“匿名函数”。
- 通常，针对 .NET Framework 3.5 及更高版本应使用 Lambda 表达式。
下面的示例演示了从 C# 1.0 到 C# 3.0 委托创建过程的发展：
View Code 
class Test
{
delegate void TestDelegate(string s);
static void M(string s)
{
Console.WriteLine(s);
}
static void Main(string[] args)
{
// C# 1.0: 最初的委托语法，用一个方法名初始化委托.
TestDelegate testdelA = new TestDelegate(M);
// C# 2.0: 用内联代码初始化委托，这个内联代码成为“匿名方法”.
// 这个方法把一个字符串作为输入参数.
TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };
// C# 3.0: 用 Lambda 表达式初始化委托.
// Lambda 表达式也把一个字符串(x)作为输入参数.
// 编译器可以推断 x 的数据类型.
TestDelegate testDelC = (x) => { Console.WriteLine(x); };
// 调用委托.
testdelA("Hello. My name is M and I write lines.");
testDelB("That's nothing. I'm anonymous and ");
testDelC("I'm a famous author.");
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
运行结果：
View Code
Hello. My name is M and I write lines.
That's nothing. I'm anonymous and
I'm a famous author.
Press any key to exit.
Lamda 表达式
“Lambda 表达式”拓展了人们对函数的认识，简化了函数定义。而委托又是一个外部函数（方法）的指针，因此，也就简化了委托。
Lambda 表达式是一个匿名函数，包含表达式或语句，可用于创建委托或表达式树类型。
表达式都使用 Lambda 运算符 =>。运算符左边是输入参数（如果有），右边包含表达式或语句块。
创建委托，如下所示：
View Code
delegate int del(int i);
static void Main(string[] args)
{
del myDelegate = x => x * x;
int j = myDelegate(5); // j = 25
}
创建表达式树，如下所示：
View Code
using System.Linq.Expressions;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Expression<del> myET = x => x * x; //
}
}
}
在基于方法的 LINQ 查询中，如 Where，Lambda 表达式作为标准查询运算符方法的参数。
Lambda 表达式
运算符右边是“Lambda 表达式”。Lambda 表达式在构造表达式树时广泛使用。Lambda 表达式返回表达式的结果，采用以下基本形式：
(input parameters) => expression
如下所示：
(x, y) => x == y
有时，编译器难于或无法推断输入类型。此时可以显式指定类型：
(int x, string s) => s.Length > x
使用空括号指定零个输入参数：
() => SomeMethod()
Lambda 语句
Lambda 语句与 Lambda 表达式类似，只是语句括在大括号中：
(input parameters) => {statement;}
Lambda 语句的主体可以包含任意数量的语句。
View Code
delegate void TestDelegate(string s);
…
TestDelegate myDel = n => { string s = n + "" + "World"; Console.WriteLine(s); };
myDel("Hello");
像匿名方法一样，Lambda 语句无法用于创建表达式树。
带有标准查询运算符的 Lambda
许多标准查询运算符都具有输入参数，其类型是泛型委托的 Func<Of T, TResult> 系列的其中之一。如Enumerable.Count 方法、Enumerable.Max 方法、Enumerable.Min 方法等等。
Func<Of T, TResult> 中的 "Of T" 表示输入参数的数量和类型；"TResult" 表示委托的返回类型。Func 委托对于应用在一组数据中每个元素非常有用。
例如，假设有以下委托类型：
View Code
public delegate TResult Func<TArg0, TResult>(TArg0 arg0)
若用 Func<int,bool> myFunc 来实例化这个委托，那么，int 是输入参数，bool 是返回值。始终在最后一个类型参数中指定返回值。若用 Func<int, string, bool> 来实例化，那么两个 int 和 string是输入参数，并且返回类型为 bool。
如下所示，调用下面 Func 委托，将返回 true 或 false 以指示输入参数是否等于 5：
View Code
Func<int, bool> myFunc = x => x == 5;
bool result = myFunc(4);
当参数类型为 Expression<Func> 时，也可以提供 Lambda 表达式，例如在 System.Linq.Queryable 内定义的标准查询运算符中。如果指定 Expression<Func> 参数，Lambda 将编译为表达式树。
如下所示，演示一个标准查询运算符 Count 方法，计算整数 (n) 除以 2 余数为 1 的整数：
View Code
int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
int oddNumbers = numbers.Count(n => n % 2 == 1);
编译器可以推断输入参数的类型，或者您也可以显式指定该类型。
如下所示，演示返回数组 9 左边的所有元素，因为 9 是序列中不满足条件的第一个数字：
View Code
var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6);
Lambda 中的类型推理
在编写 Lambda 时，通常不必为输入参数指定类型，因为编译器可以根据 Lambda 主体、基础委托类型以及 C# 语言规范中描述的其他因素推断类型。
对于大多数标准查询运算符，第一个输入是源序列中元素的类型。因此，如果要查询 IEnumerable<Customer>，则输入变量将被推断为 Customer 对象，因此你可以访问其方法和属性：
View Code
customers.Where(c => c.City == "London");
Lambda 的一般规则如下：
- Lambda 包含的参数数量必须与委托类型包含的参数数量相同。
- Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。
- Lambda 的返回值（如果有）必须能够隐式转换为委托的返回类型。
注意，Lambda 表达式本身没有类型，因为常规类型系统没有“Lambda 表达式”这一内部概念。但是，有时会不正式地论及 Lambda 表达式的“类型”。在这些情况下，类型是指委托类型或 Lambda 表达式所转换为的 Expression 类型。
如何：在查询中使用 Lambda 表达式
不会在查询语法中直接用到 Lambda 表达式，但会在方法调用中用到，并且查询表达式（查询语法）可以包含方法调用（方法语法）。事实上，某些查询操作只能用方法语法表示。
如下所示，查询语法与方法语法：
View Code
class QueryVMethodSyntax
{
static void Main()
{
int[] numbers = { 5, 10, 8, 3, 6, 12};
// 查询语法:
IEnumerable<int> numQuery1 =
from num in numbers
where num % 2 == 0
orderby num
select num;
// 方法语法:
IEnumerable<int> numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n => n);
foreach (int i in numQuery1)
{
Console.Write(i + "");
}
Console.WriteLine(System.Environment.NewLine);
foreach (int i in numQuery2)
{
Console.Write(i + "");
}
// Keep the console open in debug mode.
Console.WriteLine(System.Environment.NewLine);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
运行结果：
View Code
6 8 10 12
6 8 10 12
示例1：演示使用标准查询运算符 Enumerable.Where，基于方法语法（Lambda 表达式）查询。注意，示例中的 Where 方法具有一个委托类型为 Func<TSource, Boolean> 的输入参数，委托采用整数作为输入，并返回布尔值。可以将 Lambda 表达式转换为该委托。若是 Queryable.Where 方法（LINQ to SQL 查询），则参数类型为 Expression<Func<int,bool>>，但 Lambda 表达式看起来将完全相同。
View Code
// Enumerable.Where
// The call to Count forces iteration of the source
int[] scores = { 90, 71, 82, 93, 75, 82 };
int highScoreCount = scores.Where(n => n > 80).Count();
Console.WriteLine("{0} scores are greater than 80", highScoreCount);
// Queryable.Where
// Get all strings whose length is less than 6.
List<string> fruits = new List<string> { "apple", "passionfruit", "banana", "mango",
"orange", "blueberry", "grape", "strawberry" };
IEnumerable<string> query = fruits.AsQueryable().Where(fruit => fruit.Length < 6);
foreach (string fruit in query)
Console.WriteLine(fruit);
Console.ReadKey();
运行结果：
View Code
4 scores are greater than 80
apple
mango
grape
示例2：演示在查询语法中使用方法语法（Lambda 表达式）。Lambda 是必需的，因为无法使用查询语法来调用 Sum 标准查询运算符。
查询首先按 GradeLevel 枚举中定义的方式，依据学生的成绩等级分组。然后，对每个组，添加每个学生的总分。这需要两个 Sum 运算。内部的 Sum 计算每名学生的总分，外部的 Sum 保留该组中所有学生的运行合并总计。
View Code
// This query retrieves the total scores for First Year students, Second Years, and so on.
// The outer Sum method uses a lambda in order to specify which numbers to add together.
var categories =
from student in students
group student by student.Year into studentGroup
select new { GradeLevel = studentGroup.Key, TotalScore = studentGroup.Sum(s => s.ExamScores.Sum()) };
// Execute the query.
foreach (var cat in categories)
{
Console.WriteLine("Key = {0} Sum = {1}", cat.GradeLevel, cat.TotalScore);
}
运行结果：
View Code
Key = SecondYear Sum = 1014
Key = ThirdYear Sum = 964
Key = FirstYear Sum = 1058
Key = FourthYear Sum = 974
如何：在 LINQ 外部使用 Lambda 表达式
Lambda 表达式并不只限于在 LINQ 查询中使用。可以使用在需要委托值的任何地方（也就是在可以使用匿名方法的任何地方）。下面演示如何在 Windows 窗体事件处理程序中使用 Lambda 表达式。注意，输入的类型（Object 和 MouseEventArgs）由编译器推理，因此不必在 Lambda 输入参数中显式给定。
View Code
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
// Use a lambda expression to define an event handler.
this.Click += (s, e) => { MessageBox.Show(((MouseEventArgs)e).Location.ToString());};
}
}
匿名方法
虽然先有的匿名方法，后有的 Lambda 表达式，但仍然在 Lambda 后说明匿名方法。
在 2.0 之前的 C# 版本中，声明委托的唯一方法是使用命名方法（也就是用方法名初始化委托）。C# 2.0 引入了匿名方法，而在 C# 3.0 及更高版本中，Lambda 表达式取代了匿名方法，作为编写内联代码的首选方式。
不过，本节有关匿名方法的信息同样适用于 Lambda 表达式。有一种情况，匿名方法提供了 Lambda 表达式中所没有的功能。匿名方法使您能够省略参数列表，这意味着可以将匿名方法转换为带有各种签名的委托。这对于 Lambda 表达式来说是不可能的。
下面演示实例化委托的两种方法，都会在调用委托时显示一条消息：
- 使委托与匿名方法关联。
- 使委托与命名方法 (DoWork) 关联。
View Code
// Declare a delegate
delegate void Printer(string s);
class TestClass
{
static void Main()
{
// Instatiate the delegate type using an anonymous method:
Printer p = delegate(string j)
{
System.Console.WriteLine(j);
};
// Results from the anonymous delegate call:
p("The delegate using the anonymous method is called.");
// The delegate instantiation using a named method "DoWork":
p = new Printer(TestClass.DoWork);
// Results from the old style delegate call:
p("The delegate using the named method is called.");
}
// The method associated with the named delegate:
static void DoWork(string k)
{
System.Console.WriteLine(k);
}
}
运行结果：
View Code
The delegate using the anonymous method is called.
The delegate using the named method is called.
通过使用匿名方法，不必创建单独的方法，减少了实例化委托所需的编码系统开销。
例如，如果创建方法所需的系统开销是不必要的，则指定代码块（而不是委托）可能非常有用。启动新线程即是一个很好的示例。无需为委托创建更多方法，线程类即可创建一个线程并且包含该线程执行的代码。
View Code
void StartThread()
{
System.Threading.Thread t1 = new System.Threading.Thread
(delegate()
{
System.Console.Write("Hello, ");
System.Console.WriteLine("World!");
});
t1.Start();
}
参考资料
Wiki Lambda 表达式 http://en.wikipedia.org/wiki/Lambda_calculus
MSDN 匿名函数 http://msdn.microsoft.com/zh-cn/library/bb882516.aspx
MSDN 委托Func<Of T, TResult> http://msdn.microsoft.com/zh-cn/library/bb549151.aspx
MSDN 表达式树Expression<Func> http://msdn.microsoft.com/zh-cn/library/system.linq.expressions.expression.aspx
System.Linq.Enumerable 类 http://msdn.microsoft.com/zh-cn/library/system.linq.enumerable(v=VS.90).aspx
System.Linq.Queryable 类 http://msdn.microsoft.com/zh-cn/library/bb293129(v=VS.90).aspx
Good Math, Bad Math 关于Lambda 阐述 http://scienceblogs.com/goodmath/goodmath/lambda_calculus/