Lambda表达式

定义："Lambda表达式"是一个匿名函数，是一种高效的类似于函数式编程的表达式

好处：Lambda简化了匿名委托的使用，减少开发中需要编写的代码量 。

具体内容：它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型，支持带有可绑定到委托或表达式树的输入参数的内联表达式。

写法：所有Lambda表达式都使用Lambda运算符=>，该运算符读作"goes to"。Lambda运算符的左边是输入参数(如果有)，右边是表达式或语句块。Lambda表达式x => x * x读作"x goes to x times x"。

接下来从例子中慢慢学习：

[csharp]  view plain  copy

1. namespace LambdaLearn  
2. {  
3.     public class Person  
4.     {  
5.         public string Name { get; set; }  
6.         public int Age  {  get;set; }      
7.     }  
8.     class Program  
9.     {  
10.   
11.         public static List<Person> PersonsList()//方法返回Person类的List集合  
12.         {  
13.             List<Person> persons = new List<Person>();  
14.             for (int i = 0; i < 7; i++)  
15.             {  
16.                 Person p = new Person() { Name = i + "人物年龄", Age = 8 - i, };  
17.                 persons.Add(p);                  
18.             }  
19.             return persons;  
20.         }  
21.   
22.         static void Main(string[] args)  
23.         {  
24.             List<Person> persons0 = PersonsList();  
25.             List<Person> persons1 = persons.Where(p => p.Age > 6).ToList();   //所有Age>6的Person的集合  
26.             Person per = persons.SingleOrDefault(p => p.Age == 1);  //Age=1的单个people类  
27.             List<Person> persons2 = persons.Where(p => p.Name.Contains("年龄")).ToList();   //所有Name包含年龄的Person的集合  
28.         }  
29.     }  
30. }  

从例一可以看出一点lambda表达式的简单用法，接着往下看。

Lambda简化了匿名委托的使用，我们可以看一看下面例子怎样简化的。如果委托与事件不是很懂请看：http://blog.csdn.net/u013236878/article/details/52243017

例二：用lambda表达式简化委托

利用委托处理方法：

[csharp]  view plain  copy

1. //委托  逛超市  
2.         delegate int GuangChaoshi(int a);  
3.         static void Main(string[] args)  
4.         {  
5.             GuangChaoshi gwl = JieZhang;  
6.             Console.WriteLine(gwl(10) + "");   //打印20，委托的应用  
7.             Console.ReadKey();  
8.         }  
9.           
10.         //结账  
11.         public static int JieZhang(int a)  
12.         {  
13.             return a + 10;  
14.         }  

利用lambda表达式处理方法：

[csharp]  view plain  copy

1. //委托  逛超市  
2.         delegate int GuangChaoshi(int a);  
3.         static void Main(string[] args)  
4.         {            
5.            // GuangChaoshi gwl = JieZhang;  
6.             GuangChaoshi gwl = p => p + 10;  
7.             Console.WriteLine(gwl(10) + "");   //打印20，表达式的应用  
8.             Console.ReadKey();  
9.         }  

委托跟表达式的两段代码，我们应该能明白了：其实表达式（ p => p + 10; ）中的 p 就代表委托方法中的参数，而表达式符号右边的 p+10，就是委托方法中的返回结果。

再看一个稍微复杂一点的例子：

[csharp]  view plain  copy

1. //委托  逛超市  
2.         delegate int GuangChaoshi(int a,int b);  
3.         static void Main(string[] args)  
4.         {              
5.             GuangChaoshi gwl = (p,z) => z-(p + 10);  
6.             Console.WriteLine(gwl(10,100) + "");   //打印80，z对应参数b，p对应参数a  
7.             Console.ReadKey();  
8.         }  
9. [code]csharpcode：  
10. /// <summary>  
11.         /// 委托  逛超市  
12.         /// </summary>  
13.         /// <param name="a">花费</param>  
14.         /// <param name="b">付钱</param>  
15.         /// <returns>找零</returns>  
16.         delegate int GuangChaoshi(int a,int b);  
17.         static void Main(string[] args)  
18.         {  
19.             GuangChaoshi gwl = (p, z) =>  
20.             {  
21.                 int zuidixiaofei = 10;  
22.                 if (p < zuidixiaofei)  
23.                 {  
24.                     return 100;  
25.                 }  
26.                 else  
27.                 {  
28.                     return z - p - 10;  
29.                 }  
30.              
31.             };  
32.             Console.WriteLine(gwl(10,100) + "");   //打印80，z对应参数b，p对应参数a  
33.             Console.ReadKey();  
34.         }  

接下来看一下lambda的具体写法形式:隐式表达即没有指定参数类型( 因为编译器能够根据上下文直接推断参数的类型 )

[csharp]  view plain  copy

1. (x, y) => x * y              //多参数，隐式类型=>表达式    
2. x => x * 5                   //单参数，隐式类型=>表达式    
3. x => { return x * 5; }       //单参数，隐式类型=>语句块    
4. (int x) => x * 5             //单参数，显式类型=>表达式    
5. (int x) => { return x * 5; } //单参数，显式类型=>语句块    
6. () => Console.WriteLine()    //无参数   

看完以上内容，理解lambda表达式已经不会有太大问题了，接下来的内容稍微会深一点（至少我理解了很久Orz...）

简单了解一下lambda背景：

Lambda 用在基于方法的 LINQ 查询中，作为诸如 Where 和 Where 等标准查询运算符方法的参数。

使用基于方法的语法在 Enumerable 类中调用 Where 方法时（像在 LINQ to Objects 和 LINQ to XML 中那样），参数是委托类型 System..::.Func<(Of <(T, TResult>)>)。使用 Lambda 表达式创建委托最为方便。例如，当您在 System.Linq..::.Queryable 类中调用相同的方法时（像在 LINQ to SQL 中那样），则参数类型是 System.Linq.Expressions..::.Expression<Func>，其中 Func 是包含至多五个输入参数的任何 Func 委托。同样，Lambda 表达式只是一种用于构造表达式目录树的非常简练的方式。尽管事实上通过 Lambda 创建的对象的类型是不同的，但 Lambda 使得 Where 调用看起来类似。

背景这种想要深入研究的可以都了解一下，本文只是帮助了解lambda，这里就不多说了。

下列规则适用于 Lambda 表达式中的变量范围：

捕获的变量将不会被作为垃圾回收，直至引用变量的委托超出范围为止。

在外部方法中看不到 Lambda 表达式内引入的变量。

Lambda 表达式无法从封闭方法中直接捕获 ref 或 out 参数。

Lambda 表达式中的返回语句不会导致封闭方法返回。

Lambda 表达式不能包含其目标位于所包含匿名函数主体外部或内部的 goto 语句、break 语句或 continue 语句。

Lambda表达式的本质是“匿名方法”，即当编译我们的程序代码时，“编译器”会自动将“Lambda表达式”转换为“匿名方法”，如下例：

[csharp]  view plain  copy

1. string[] names={"agen","balen","coure","apple"};  
2. string[] findNameA=Array.FindAll<string>(names,delegate(string v){return v.StartsWith("a");});  
3. string[] findNameB=Array.FindAll<string>(names,v=>v.StartsWith("a"));  

上面中两个FindAll方法的反编译代码如下：

[csharp]  view plain  copy

1. string[]findNameA=Array.FindAll<string>(names,delegate(stringv){returnv.StartsWith("a");});  
2. string[]findNameB=Array.FindAll<string>(names,delegate(stringv){returnv.StartsWith("a");});  

Lambda表达式的语法格式：

参数列表 => 语句或语句块

其中“参数列”中可包含任意个参数(与委托对应），如果参数列中有0个或1个以上参数，则必须使用括号括住参数列，如下：

() => Console.Write("0个参数")

I => Console.Write("1个参数时参数列中可省略括号，值为：{0}",i)

(x,y) => Console.Write("包含2个参数，值为：{0}*{1}",x,y)

而“语句或语句块”中如果只有一条语句，则可以不用大括号括住否则必须使用，如下：

I => Console.Write("只有一条语句")

I => { Console.Write("使用大括号的表达式"); }

//两条语句时必须要大括号

I => { i++;Console.Write("两条语句的情况"); }

如果“语句或语句块”有返回值时，如果只有一条语句则可以不输写“return”语句， 编译器会自动处理，否则必须加上，如下示例：

“Lambda表达式”是委托的实现方法，所以必须遵循以下规则：

1）“Lambda表达式”的参数数量必须和“委托”的参数数量相同；

2）如果“委托”的参数中包括有ref或out 修饰符，则“Lambda表达式”的参数列中也必须包括有修饰符；