Lambda表达式可以简化C#编程的某些方面，用法非常灵活。因此也不容易掌握。

下边是我学Lambda表达式的一点记录。

1、Lambda表达式是与委托紧密联系的。只要有委托参数类型的地方，就可以使用Lambda表达式。

Lambda表达式的运算符是=>。运算符左边列举出了需要的参数，右边定义了赋予Lambda变量的方法的实现代码。下面这段代码是一个最简单的使用方法：

[csharp] view plaincopy
  1. public class MyLambda  
  2. {  
  3.     public void disPlay()  
  4.     {  
  5.         string mid = ",middle part,";  
  6.         Func<string, string> lambda = param =>  
  7.             {  
  8.                 param += mid;  
  9.                 param += "and this was added to the string";  
  10.                 return param;  
  11.             };  
  12.         Console.WriteLine(lambda("Start of string"));  
  13.     }  
  14. }  

Func<string,string>是一个委托类型。包含两个参数：一个输入的string和一个输出的string.

param是输入参数，所以他的类型可以认为是string类型的（当然很多地方会出现没有名字的类型的）。

运算符=>右边表示一个方法，这个方法没有名字。这个方法赋予了变量lambda。

在本例中，通过Console.WriteLine(lambda("Start of string"));向lambda方法传递参数“Start of string”.经处理后会有这样的输出：

Start of string,middle part,and this was added to the string。

所以我想这样理解：Lambda表达式表示是一个函数的另一种写法。运算符=>左边是输入，右边是函数体。函数体需不需要返回值，由接收这个函数定义的lambda表达式的委托决定。

2、Lambda表达式的参数。

lambda表达式如果只有一个参数，只写出参数名就行了。下边的lambda表达式使用了参数s，因为委托类型定义了一个string类型。所以 s的类型就是string。实现函数体的代码调用了String.Format()方法返回一个字符串，在调用委托是就直接把字符串输出了：

[csharp] view plaincopy
  1. Func<string, string> oneParam = s =>  
  2.     {  
  3.         return String.Format("Change To UpperCase {0}", s.ToUpper());  
  4.     };  
  5.   
  6.   
  7. Console.WriteLine( oneParam("abc"));  

注：Func的用法见下一篇博文.Func<string,string>是一个系统定义的带有一个输入和一个输出的委托。

如果委托有多个参数，就要把参数放到括号中，如下：

[csharp] view plaincopy
  1. Func<double, double, double> twoParam = (x, y) =>  
  2.     {  
  3.         return x * y;  
  4.     };  

3、单行代码和多行代码

如果Lambda表达式只有一条语句，在方法块内就不需要花括号和return语句了，编译器会自动添加一条隐式的return语句。如上边的两个表达式可以分别表示为：

[csharp] view plaincopy
  1. Func<string, string> oneParam = s => String.Format("Change To UpperCase {0}", s.ToUpper());  
  2. Func<double, double, double> twoParam = (x, y) => x * y;  

但是如果Lambda表达式实现代码需要多条语句时，就必须添加花括号和return语句了。如第一个例子的代码。

4、Lambda表达式的外部变量

Lambda表达式可以使用外部变量。但使用时应该注意些问题：

先看下边的代码：

[csharp] view plaincopy
  1. int someVar = 5;  
  2. Func<int, int> f = x => x + someVar;  
  3. someVar = 10;  
  4. Console.WriteLine(f(5));  

输出应该是x+5还是x+10呢？运行下发现输出15（x+10）.即修改外部变量someVar后，会使用外部变量的新值。

对于表达式x => x + someVar; 编译器会创建一个匿名类，他有一个构造函数来传递外部变量。该构造函数取决于从外部传递过来的变量个数。对于上边这个例子，我们可以认为构造函数接受一个 int，匿名类包含了一个匿名方法，其实现代码和返回类型有lambda表达式定义：

[csharp] view plaincopy
  1. public class AnonymousClass  
  2. {  
  3.     private int someVar;  
  4.     public AnonymousClass(int someVar)  
  5.     {  
  6.         this.someVar = someVar;  
  7.     }  
  8.     public int AnonymousMethod(int x)  
  9.     {  
  10.         return x + someVar;  
  11.     }  
  12. }  

使用Lambda表达式时，调用该方法（AnonymousMethod（int x）），会创建匿名类的一个实例（相当于new AnonymousClass(somevar)），并传递调用该方法时的变量的值。