[C# 基础知识系列]专题十四：深入理解Lambda表达式

 引言：

 　　对于刚刚接触Lambda表达式的朋友们，可能会对Lambda表达式感到非常疑惑，它到底是个什么什么样的技术呢?以及它有什么好处和先进的地方呢？下面的介绍将会解除你这些疑惑。

一、Lambda表达式的演变过程

Lambda表达式其实大家可以理解为它是一个匿名函数（对于匿名函数的介绍大家可以参考我这篇文章）, Lambda表达式可以包含表达式和语句,并且可以用于创建委托,以及C#编译器也能将它转换成表达式树。

对于Lambda表达式中都会使用这个运算符——“=>”，它读成“goes to” ,该运算符的左边为输入参数，右边是表达式或者语句块,下面就看看Lambda表达式是如何来创建委托实例（代码同时也给出了Lambda表达式从匿名方法的演示过程，从而帮助大家更好的理解Lambda表达式是匿名函数的概念，只不过C#3 中提出的Lambda表达式比匿名函数的使用更加简洁和直观了，其实原理都是一样的， 编译器同样会把Lambda表达式编译成匿名函数，也就是一个名字的方法）：

1. using System; 
2.  
3. namespace Lambda表达式Demo 
4. { 
5.     class Program 
6.     { 
7.         /// <summary> 
8.         /// Lambda 表达式使用演示 
9.         /// </summary> 
10.         /// <param name="args"></param> 
11.         static void Main(string[] args) 
12.         { 
13.             // Lambda表达式的演变过程 
14.             // 下面是C# 1中创建委托实例的代码 
15.             Func<string, int> delegatetest1 = new Func<string, int>(Callbackmethod); 
16.              
17.             //                                  ↓ 
18.             // C# 2中用匿名方法来创建委托实例，此时就不需要额外定义回调方法Callbackmethod 
19.             Func<string, int> delegatetest2 = delegate(string text) 
20.             { 
21.                 return text.Length; 
22.             }; 
23.  
24.             //                                  ↓ 
25.             // C# 3中使用Lambda表达式来创建委托实例 
26.             Func<string, int> delegatetest3 = (string text) => text.Length; 
27.  
28.             //                                  ↓ 
29.             // 可以省略参数类型string,把上面代码再简化为： 
30.             Func<string, int> delegatetest4 = (text) => text.Length; 
31.  
32.             //                                  ↓ 
33.             // 如果Lambda表达式只需一个参数，并且那个参数可以隐式指定类型时， 
34.             // 此时可以把圆括号也省略,简化为： 
35.             Func<string, int> delegatetest = text => text.Length; 
36.  
37.             // 调用委托 
38.             Console.WriteLine("使用Lambda表达式返回字符串的长度为： " + delegatetest("learning hard")); 
39.             Console.Read(); 
40.         } 
41.  
42.         /// <summary> 
43.         /// 回调方法 
44.         /// 如果使用了Lambda表达式和匿名函数，此方法就不需要额外定义 
45.         /// </summary> 
46.         /// <param name="text"></param> 
47.         /// <returns></returns> 
48.         private static int Callbackmethod(string text) 
49.         { 
50.             return text.Length; 
51.         } 
52.     } 
53. } 

运行结果为:

上面代码中都有详细的演变过程,这里就不多解释了,希望通过这部分之后,大家可以对Lambda表达式有进一步的理解，其实Lambda表达式就是匿名方法，其中使用Lambda表达式来创建委托实例，我们却没有指出创建的委托类型，其中编译器会帮助我们去推断委托类型，从而简化我们创建委托类型所需要的代码，从而更加简洁，所以Lambda表达式可以总结为——它是在匿名方法的基础上，再进一步地简化了创建委托实例所需要的代码。

二、Lambda表达式的使用

为了帮助大家更好的理解Lambda表达式，下面演示下用Lambda表达式来记录事件(代码中Lambda运算符的右边调用了一个回调方法ReportEvent())：

1. using System; 
2. using System.Windows.Forms; 
3.  
4. namespace Lambda表达式来记录事件Demo 
5. { 
6.     class Program 
7.     { 
8.         static void Main(string[] args) 
9.         { 
10.             // 新建一个button实例 
11.             Button button1 = new Button() { Text ="点击我"}; 
12.  
13.             // C# 2中使用匿名方法来订阅事件 
14.             //button1.Click+=delegate (object sender,EventArgs e) 
15.             //{ 
16.             //    ReportEvent("Click事件", sender, e); 
17.             //}; 
18.             //button1.KeyPress += delegate (object sender, KeyPressEventArgs e) 
19.             //{ 
20.             //    ReportEvent("KeyPress事件，即键盘按下事件", sender, e); 
21.             //}; 
22.  
23.             // C# 3Lambda表达式方式来订阅事件 
24.             // 与上面使用匿名方法来订阅事件是不是看出简单了很多，并且也直观了 
25.             button1.Click += (sender, e) => ReportEvent("Click事件", sender, e); 
26.             button1.KeyPress += (sender, e) => ReportEvent("KeyPress事件，即键盘按下事件", sender, e); 
27.  
28.             // C# 3之前初始化对象时使用下面代码 
29.             //Form form = new Form(); 
30.             //form.Name = "在控制台中创建的窗体"; 
31.             //form.AutoSize = true; 
32.             //form.Controls.Add(button1); 
33.  
34.             // C# 3中使用对象初始化器 
35.             // 与上面代码的比较中，也可以看出使用对象初始化之后代码简化了很多 
36.             Form form = new Form { Name = "在控制台中创建的窗体", AutoSize = true, Controls = { button1 } }; 
37.            
38.             // 运行窗体 
39.             Application.Run(form); 
40.         } 
41.  
42.         // 记录事件的回调方法 
43.         private static void ReportEvent(string title, object sender, EventArgs e) 
44.         { 
45.             Console.WriteLine("发生的事件为：{0}", title); 
46.             Console.WriteLine("发生事件的对象为：{0}", sender); 
47.             Console.WriteLine("发生事件参数为： {0}", e.GetType()); 
48.             Console.WriteLine(); 
49.             Console.WriteLine(); 
50.         } 
51.     } 
52. } 

运行结果:

从上面代码中可以看出,使用Lambda表达式之后代码确实简洁了很多，上面代码中都有详细的注释，这里就不解释了，大家可以查看代码中的注释来进行理解，并且代码中注释部分也列出了C# 3之前是如何实现这样的代码的， 这样有利于比较，从而帮助大家更好的认识到Lambda所带来的好处和进一步来理解Lambda表达式。

三、表达式树

上面指出Lambda表达式除了可以用来创建委托外，C#编译器还可以将他们转换成表达式树——用于表示Lambda表达式逻辑的一种数据结构，表达式树也可以称作表达式目录树，它将代码表示成一个对象树，而不是可执行的代码。对于刚接触哦表达式树的朋友肯定会问——为什么需要把Lambda表达式转化为表达式目录树呢？对于表达式树的提出主要是为后面Linq to SQL 做铺垫，一个Linq to SQL 的查询语句并不是在C#的程序中执行的，而是C#编译器把它转化为SQL 语句,然后再在数据库中执行。在我们使用Linq to SQL的时候都需要添加一个Linq to SQL的类，该类的扩展名dbml,该的作用就是帮助我们把Linq to SQL 的语句映射为SQL语句，然后再在数据库中执行SQL语句，把返回的结果再返回给一个IQueryable集合,所以Linq to SQL 也采用了通常的ORM（Object—Relationship—Mapping）来设计的，相当于是一个ORM框架，不过这个框架只能与微软的SQL server数据库进行映射，对于其他类型的数据库却不可以，然而很多其他开发人员却对此进行了一些扩展，扩展了对其他数据库的支持。前不久还在博客园中发布了开源的Linq框架的，名字为ELinq,其他它就是对Linq to SQL的一个扩展，使Linq语句可以映射到其他数据库的查询语句。

下面先看看如何把Lambda表达式转化为表达式目录树(其中需要引入一个新的命名空间—— System.Linq.Expressions)：

1. using System; 
2.  
3. // 引用额外的命名空间 
4. using System.Linq.Expressions; 
5.  
6. namespace 表达式树Demo 
7. { 
8.     class Program 
9.     { 
10.         /// <summary> 
11.         /// 表达式树的演示 
12.         /// </summary> 
13.         /// <param name="args"></param> 
14.         static void Main(string[] args) 
15.         { 
16.             #region 将Lambda表达式转换为表达式树演示 
17.             // 将Lambda表达式转换为Express<T>的表达式树 
18.             // 此时express不是可执行的代码，它现在是一个表达式树的数据结构 
19.             Console.WriteLine("将Lambda表达式转化为表达式树的演示："); 
20.             Expression<Func<int, int, int>> expression = (a, b) => a + b; 
21.  
22.             // 获得表达式树的参数 
23.             Console.WriteLine("参数1： {0},参数2：{1}", expression.Parameters[0],expression.Parameters[1]); 
24.  
25.             // 既然叫做树，那肯定有左右节点 
26.             // 获取表达式树的主体部分 
27.             BinaryExpression body = (BinaryExpression)expression.Body; 
28.              
29.             // 左节点,每个节点本身就是一个表达式对象 
30.             ParameterExpression left = (ParameterExpression)body.Left; 
31.  
32.             // 右节点 
33.             ParameterExpression right = (ParameterExpression)body.Right; 
34.  
35.             Console.WriteLine("表达式主体为："); 
36.             Console.WriteLine(expression.Body); 
37.             Console.WriteLine("表达式树左节点为：{0}{4} 节点类型为：{1}{4}{4} 表达式右节点为：{2}{4} 节点类型为：{3}{4}", left.Name, left.NodeType, right.Name, right.NodeType,Environment.NewLine); 
38.             Console.Read(); 
39.             #endregion  
40.  
41.             #region 把表达式树转化回可执行代码 
42.  
43.             // Compile方法生成Lambda表达式的委托 
44.             Console.WriteLine("按下Enter键进入将表达式树转换为Lambda表达式的委托演示："); 
45.             int result = expression.Compile()(2, 3); 
46.             Console.WriteLine("调用Lambda表达式委托结果为：" + result); 
47.             Console.ReadKey(); 
48.             #endregion 
49.         } 
50.     } 
51. } 

运行结果:

上面代码首先把Lambda表达式转化为表达式树,下面这行代码就是把Lambda表达式转化为表达式树：

1. Expression<Func<int, int, int>> expression = (a, b) => a + b; 

之后对于表达式树这种数据结构进行分析来获得该树中的主体和左右节点是什么,获得主体和左右节点的代码如下:

1. // 获取表达式树的主体部分 
2.             BinaryExpression body = (BinaryExpression)expression.Body; 
3.              
4.             // 左节点,每个节点本身就是一个表达式对象 
5.             ParameterExpression left = (ParameterExpression)body.Left; 
6.  
7.             // 右节点 
8.             ParameterExpression right = (ParameterExpression)body.Right; 

从上面代码可以得出——树中的每个节点都是一个表达式(ParameterExpression和BinaryExpression都是继承Expression的，所以左右节点都是表达式),分析完表达式树之后,代码中还演示了如果把表达式树转化为可执行的代码,即转化为Lambda表达式的委托对象（此时调用Expression的Compile()方法来转化为可执行代码），通过调用委托来获得结果。 

 关于Lambda表达式树的更多信息还可以参看这篇博客：http://www.cnblogs.com/tianfan/archive/2010/03/05/expression-tree-basics.html (博主翻译的还可以) 

四、总结

 到这里本专题的内容也介绍的差不多了，希望通过本专题使一些之前对Lambda表达式感到疑惑的朋友们现在可以理解Lambda表达式，因为只有理解好Lambda表达式之后，对于Linq的学习就可以说是轻而易举了。