Lambda表达式总结

 

“Lambda 表达式”是一个匿名函数，它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型。

                     所有 Lambda 表达式都使用 Lambda 运算符 =>，该运算符读为“goes to”。该 Lambda 运算符的左边是输入参数（如果有），右边包含表达式或语句块。Lambda 表达式 x => x * x 读作“x goes to x times x”。

Lambda表达式（输入参数）X=>X*X(表达式或者语句块：这里是表达式)该Lambda表达式的含义就是左边输入参数的值为右边X*X表达式的值

可以将此表达式分配给委托类型，如下所示：

 

delegate int del(int i);//定义一个 返回值为int数据类型的带有整形参数的委托类型 del myDelegate = x => x * x;//声明一个委托变量myDelegate 、用Lambda表达式给与赋值 int j = myDelegate(5); //j = 25//委托的调用情况 ，采用右结合的方式得出X的值为25

创建表达式目录树类型：                

 

using System.Linq.Expressions; // ... Expression<del> = x => x * x;

=> 运算符具有与赋值运算符 (=) 相同的优先级，并且是右结合运算符。                

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 调用看起来类似。                

                     在前面的示例中，请注意委托签名具有一个 int 类型的隐式类型输入参数，并返回 int。可以将 Lambda 表达式转换为该类型的委托，因为该表达式也具有一个输入参数 (x)，以及一个编译器可隐式转换为 int 类型的返回值。（以下几节中将对类型推理进行详细讨论。）使用输入参数 5 调用委托时，它将返回结果 25。                

                     在 is 或 as 运算符的左侧不允许使用 Lambda。                

  Lambda 表达式

                     表达式在右边的 Lambda 表达式称为“Lambda 表达式”。Lambda 表达式在构造       表达式目录树时广泛使用。Lambda 表达式返回表达式的结果，并采用以下基本形式：                

 

(input parameters) => expression

只有在 Lambda 有一个输入参数时，括号才是可选的；否则括号是必需的。两个或更多输入参数由括在括号中的逗号分隔：                

 

(x, y) => x == y

有时，编译器难于或无法推断输入类型。如果出现这种情况，您可以按以下示例中所示方式显式指定类型：                

 

(int x, string s) => s.Length > x

使用空括号指定零个输入参数：                

 

() => SomeMethod()

在上一个示例中，请注意 Lambda 表达式的主体可以包含方法调用。但是，如果要创建将在另一个域（比如 SQL Server）中使用的表达式目录树，则不应在 Lambda 表达式中使用方法调用。方法在 .NET 公共语言运行时上下文的外部将没有意义。

在上一个示例中，请注意 Lambda 表达式的主体可以包含方法调用。但是，如果要创建将在另一个域（比如 SQL Server）中使用的表达式目录树，则不应在 Lambda 表达式中使用方法调用。方法在 .NET 公共语言运行时上下文的外部将没有意义。

  许多标准查询运算符都具有输入参数，其类型是泛型委托的 Func<(Of <(T, TResult>)>)

 

系列的其中之一。Func<(Of <(T, TResult>)>) 委托使用类型参数来定义输入参数的数量和类型，以及委托的返回类型。Func 委托对于封装应用于一组源数据中每个元素的用户定义表达式非常有用。例如，假设有以下委托类型：                

 

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：                

 

    Func<int, bool> myFunc = x => x == 5;     bool result = myFunc(4); // returns false of course

当参数类型为 Expression<Func> 时，您也可以提供 Lambda 表达式，例如在 System.Linq.Queryable 内定义的标准查询运算符中。如果指定 Expression<Func> 参数，Lambda 将编译为表达式目录树。                

                     此处显示了一个标准查询运算符，Count 方法：                

 

    int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };     int oddNumbers = numbers.Count(n => n % 2 == 1);

编译器可以推断输入参数的类型，或者您也可以显式指定该类型。这个特别的 Lambda 表达式将计算整数 (n) 的数量，这些整数除以 2 时余数为 1。                

                     以下方法将生成一个序列，其中包含数字数组中出现在“9”之前的所有元素，因为“9”是序列中不满足条件的第一个数字：                

 

    var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6);

此示例演示如何通过将输入参数括在括号中来指定多个输入参数。该方法将返回数字数组中的所有元素，直至遇到一个值小于其位置的数字为止。不要将 Lambda 运算符 (=>) 与大于等于运算符 (=>) 混淆。                

 

    var firstSmallNumbers = numbers.TakeWhile((n, index) => n >= index);

  Lambda 中的类型推理

在编写 Lambda 时，通常不必为输入参数指定类型，因为编译器可以基于 Lambda 主体、基础委托类型以及 C# 3.0 语言规范中描述的其他因素推断类型。对于大多数标准查询运算符，第一个输入是源序列中的元素的类型。因此，如果要查询 IEnumerable<Customer>，则输入变量将被推断为 Customer 对象，这意味着您可以访问其方法和属性：                

 

customers.Where(c => c.City == "London");

                     Lambda 的一般规则如下：                

• Lambda 包含的参数数量必须与委托类型包含的参数数量相同。                

• Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。                

• Lambda 的返回值（如果有）必须能够隐式转换为委托的返回类型。                

请注意，Lambda 表达式本身没有类型，因为通用类型系统没有“Lambda 表达式”这一内部概念。但是，有时会不正式地论及 Lambda 表达式的“类型”。在这些情况下，类型是指委托类型或 Lambda 表达式所转换为的 Expression 类型。

在编写 Lambda 时，通常不必为输入参数指定类型，因为编译器可以基于 Lambda 主体、基础委托类型以及 C# 3.0 语言规范中描述的其他因素推断类型。对于大多数标准查询运算符，第一个输入是源序列中的元素的类型。因此，如果要查询 IEnumerable<Customer>，则输入变量将被推断为 Customer 对象，这意味着您可以访问其方法和属性：                

 

customers.Where(c => c.City == "London");

                     Lambda 的一般规则如下：                

• Lambda 包含的参数数量必须与委托类型包含的参数数量相同。                

• Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。                

• Lambda 的返回值（如果有）必须能够隐式转换为委托的返回类型。                

请注意，Lambda 表达式本身没有类型，因为通用类型系统没有“Lambda 表达式”这一内部概念。但是，有时会不正式地论及 Lambda 表达式的“类型”。在这些情况下，类型是指委托类型或 Lambda 表达式所转换为的 Expression 类型。

 

Lambda 可以引用“外部变量”，这些变量位于在其中定义 Lambda 的封闭方法或类型的范围内。将会存储通过这种方法捕获的变量以供在 Lambda 表达式中使用，即使变量将以其他方式超出范围或被作为垃圾回收。必须明确地分配外部变量，然后才能在 Lambda 表达式中使用该变量。下面的示例演示这些规则：

 

　 delegate bool D();    
 　delegate bool D2(int i);
   class Test    
　 {         
　　　　　　　　　　　　
　　　　　　D del;         D2 del2;        
　　　　　　 public void TestMethod(int input)         
　　　　　　 {             
　　　　　　　　　　int j = 0;                     
　　　　          del = () => { j = 10;  return j > input; };
                 del2 = (x) => {return x == j; };                    
   　　　　　　　　 Console.WriteLine("j = {0}", j);
                 bool boolResult = del();
                 Console.WriteLine("j = {0}. b = {1}", j, boolResult);         }
        　　　　　　static void Main()        
　　　　　　　　　　 {             
　　　　　　　　　　　　　　Test test = new Test();            
　　　　　　　　　　　　   test.TestMethod(5);
            　　　　　　 bool result = test.del2(10);
                       Console.WriteLine(result);                         
　　　　　　　　　　　　　 Console.ReadKey();         
　　　　　　　　　　　}     
　　　　}

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

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

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

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

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

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

Lambda表达式为编写匿名方法提供了更简明的函数式的句法，但结果却在编写LINQ查询表达式时变得极其有用，因为它们提供了一个非常紧凑的而且类安全的方式来编写可以当作参数来传递，在以后作运算的函数。

创建Lambda表达式

Lambda表达式的书写方式是一个参数列表后跟“=>”记号，然后跟一个表达式或一个语句块，即Lambda表达式的语法格式为：参数列 => 语句或语句块

Lambda表达式例子如下所示：

delegate int del(int i);

del myDelegate = x => x * x;

int j = myDelegate(5); //j = 25

关于“参数列”，Lambda表达式的参数列可以具有显式的或隐式的类型。在一个具有显式类型的参数列表中，每个参数的类型都是显式声明的。在一个具有隐式类型的参数列表中，参数的类型是从Lambda表达式出现的上下文中推断出来的——具体来说，是当Lambda表达式被转换为一个兼容的委托类型时，该委托类型提供了参数的类型。

当Lambda表达式只有一个具有隐式类型的参数时，参数列表中的括号可以省略。即：

(param) => expr可以简写为：param => expr

最后，参数列中可包含任意个参数（与委托对应），如果参数列中有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”语句，编译器会自动处理，否则必须加上，如下示例：

class Test

    {

        delegate int AddHandler(int x, int y);

        static void Print(AddHandler add)

        {

            Console.Write(add(1, 3));

        }

        static void Main()

        {

            Print((x, y) => x + y);

            Print((x, y) => { int v = x * 10; return y + v; });

            Console.Read();

        }

    }

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

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

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

我们来看如下例子：

class Test

    {

        delegate void OutHandler(out int x);

        static void Print(OutHandler test)

        {

            int i;

            test(out i);

            Console.Write(i);

        }

        static void Main()

        {

            Print((out int x) => x = 3);

            Console.Read();

        }

    }

如果委托有返回类型，则Lambda表达式的语句或语句块中也必须返回相同类型的数据；

如果委托有几种数据类型格式而在Lambda表达式中编译器无法推断具体数据类型时，则必须手动明确数据类型。

由上面可见，C# 2.0规范中提到的匿名方法规范同样适用于Lambda表达式。Lambda表达式是匿名方法在功能行上的超集，提供了下列附加的功能：

Lambda表达式允许省略参数类型并对其进行推断，而匿名方法要求参数类型必须显式地声明。

Lambda表达式体可以是表达式或语句块，而匿名方法体只能是语句块。

在类型参数推导和方法重载抉择时，Lambda表达式可以被作为参数传递。

以一个表达式作为表达式体的Lambda表达式可以被转换为表达式树。

Lambda表达式转换

和匿名方法表达式类似，Lambda表达式可以归类为一种拥有特定转换规则的值。这种值没有类型，但可以被隐式地转换为一个兼容的委托类型。特别地，当满足下列条件时，委托类型D兼容于Lambda表达式L：

D和L具有相同数量的参数；

如果L具有显式类型的参数列表，D中每个参数的类型和修饰符必须和L中相应的参数完全一致；

如果L具有隐式类型的参数列表，则D中不能有ref或out参数；

如果D具有void返回值类型，并且L的表达式体是一个表达式，若L的每个参数的类型与D的参数一致，则L的表达式体必须是一个可接受为statement-expression的有效表达式；

如果D具有void返回值类型，并且L的表达式体是一个语句块，若L的每个参数的类型与D的参数一致，则L的表达式体必须是一个有效语句块，并且该语句块中不能有带有表达式的return语句；

如果D的返回值类型不是void，并且L的表达式体是一个表达式，若L的每个参数的类型与D的参数一致，则L的表达式体必须是一个可以隐式转换为D的返回值类型的有效表达式；

如果D的返回值类型不是void，并且L的表达式体是一个语句块，若L的每个参数的类型与D的参数一致，则L的表达式体必须是一个有效的语句块，该语句块不能有可达的终点（即必须有return语句），并且每个return语句中的表达式都必须能够隐式转换为D的返回值类型。

后面的例子将使用一个范型委托F<U, T>表示一个函数，它具有一个类型为U的参数u，返回值类型为T：

delegate T F<U, T>(U u);

我们可以像在下面这样赋值：

F<int, int> f1 = x => x + 1;          

F<int, double> f2 = x => x + 1;

每个Lambda表达式的参数和返回值类型通过将Lambda表达式赋给的变量的类型来检测。第一个赋值将Lambda表达式成功地转换为了委托类型Func<int, int>，因为x的类型是int，x + 1是一个有效的表达式，并且可以被隐式地转换为int。同样，第二个赋值成功地将Lambda表达式转换为了委托类型Func<int, double>，因为x + 1的结果（类型为int）可以被隐式地转换为double类型。

来看如下代码，如果这样赋值会怎么样？

F<double, int> f3 = x => x + 1;

我们运行上面的代码，编译器会报如下两条错误：

（1）无法将类型“double”隐式转换为“int”。存在一个显式转换（是否缺少强制转换?）。

（2）无法将Lambda表达式转换为委托类型“F<double，int>”，原因是块中的某些返回类型不能隐式转换为委托返回类型。

其实产生一个编译期错误原因是，x给定的类型是double，x + 1的结果（类型为double）不能被隐式地转换为int。

类型推断

当在没有指定类型参数的情况下调用一个范型方法时，一个类型推断过程会去尝试为该调用推断类型参数。被作为参数传递给范型方法的Lambda表达式也会参与这个类型推断过程。

最先发生的类型推断独立于所有参数。在这个初始阶段，不会从作为参数的Lambda表达式推断出任何东西。然而，在初始阶段之后，将通过一个迭代过程从Lambda表达式进行推断。特别地，当下列条件之一为真时将会完成推断：

  参数是一个Lambda表达式，以后简称为L，从其中未得到任何推断；

相应参数的类型，以后简称为P，是一个委托类型，其返回值类型包括了一个或多个方法类型参数；

P和L具有相同数量的参数，P中每个参数的修饰符与L中相应的参数一致，或者如果L具有隐式类型的参数列表时，没有参数修饰符；

P的参数类型不包含方法类型参数，或仅包含于已经推断出来的类型参数相兼容的一组类型参数；

如果L具有显式类型的参数列表，当推断出来的类型被P中的方法类型参数取代了时，P中的每个参数应该具有和L中相应参数一致的类型。

如果L具有隐式类型的参数列表，当推断出来的类型被P中的方法类型参数取代了并且作为结果的参数类型赋给了L时，L的表达式体必须是一个有效的表达式或语句块。

可以为L推断一个返回值类型。

对于每一个这样的参数，都是通过关联P的返回值类型和从L推断出的返回值类型来从其上进行推断的，并且新的推断将被添加到累积的推断集合中。这个过程一直重复，直到无法进行更多的推断为止。

在类型推断和重载抉择中，Lambda表达式L的“推断出来的返回值类型”通过以下步骤进行检测：

  如果L的表达式体是一个表达式，则该表达式的类型就是L的推断出来的返回值类型。

   如果L的表达式体是一个语句块，若由该块中的return语句中的表达式的类型形成的集合中恰好包含一个类型，使得该集合中的每个类型都能隐式地转换为该类型，并且该类型不是一个空类型，则该类型即是L的推断出来的返回值类型。

除此之外，无法从L推断出一个返回值类型。

作为包含了Lambda表达式的类型推断的例子，请考虑System.Query.Sequence类中声明的Select扩展方法：

namespace System.Query

    {

        public static class Sequence

        {

            public static IEnumerable<S> Select<T, S>(

                this IEnumerable<T> source,

                Func<T, S> selector)

            {

                foreach (T element in source) yield return selector(element);

            }

        }

    }

假设使用using语句导入了System.Query命名空间，并且定义了一个Customer类，具有一个类型为string的属性Name，Select方法可以用于从一个Customer列表中选择名字：

List<Customer> customers = GetCustomerList();

IEnumerable<string> names = customers.Select(c => c.Name);

对扩展方法Select的调用将被处理为一个静态方法调用：

IEnumerable<string> names = Sequence.Select(customers, c => c.Name);

由于没有显式地指定类型参数，将通过类型推断来推导类型参数。首先，customers参数被关联到source参数，T被推断为Customer。然后运用上面提到的拉姆达表达式类型推断过程，C的类型是Customer，表达式c.Name将被关联到selector参数的返回值类型，因此推断S是string。因此，这个调用等价于：

Sequence.Select<Customer, string>(customers, (Customer c) => c.Name);

并且其返回值类型为IEnumerable<string>。

下面的例子演示了Lambda表达式的类型推断是如何允许类型信息在一个范型方法调用的参数之间“流动”的。对于给定的方法：

static Z F<X, Y, Z>(X value, Func<X, Y> f1, Func<Y, Z> f2) { return f2(f1(value)); }

现在我们来写这样一个调用，来看看它的推断过程：

double seconds = F("1:15:30", s => TimeSpan.Parse(s), t => TotalSeconds);

类型推断过程是这样的：首先，参数"1:15:30"被关联到value参数，推断X为string。然后，第一个Lambda表达式的参数s具有推断出来的类型string，表达式TimeSpan.Parse（s）被关联到f1的返回值类型，推断Y是System.TimeSpan。最后，第二个Lambda表达式的参数t具有推断出来的类型System.TimeSpan，并且表达式t.TotalSeconds被关联到f2的返回值类型，推断Z为double。因此这个调用的结果类型是double。

重载抉择

参数列表中的Lambda表达式将影响到特定情形下的重载抉择（也称重载分析，重载解析等，即从几个重载方法中选择最合适的方法进行调用的过程）。

下面是新添加的规则：

对于Lambda表达式L，且其具有推断出来的返回值类型，当委托类型D1和委托类型D2具有完全相同的参数列表，并且将L的推断出来的返回值类型隐式转换为D1的返回值类型要优于将L的推断出来的返回值类型隐式转换为D2的返回值类型时，称L到D1的隐式转换优于L到D2的隐式转换。如果这些条件都不为真，则两个转换都不是最优的。

表达式树

表达式树允许将Lambda表达式表现为数据结构而不是可执行代码。一个可以转换为委托类型D的Lambda表达式，也可以转换为一个类型为System.Linq.Expressions. Expression<D>的表达式树。将一个Lambda表达式转换为委托类型导致可执行代码被委托所生成和引用，而将其转换为一个表达式树类型将导致创建了表达式树实例的代码被发出。表达式树是Lambda表达式的一种高效的内存中数据表现形式，并且使得表达式的结构变得透明和明显。

如下面的例子将一个Lambda表达式分别表现为了可执行代码和表达式树。由于存在到Func<int, int>的转换，因此存在到Expression<Func<int, int>>的转换。代码如下所示：

using System.Linq.Expressions；

// 代码

Func<int, int> f = x => x + 1;

// 数据

Expression<Func<int, int>> e = x => x + 1;

在这些赋值完成之后，委托f标识一个返回x + 1的方法，而表达式树e表示一个描述了表达式x + 1的数据结构。

Lambda表达式的例子：

在我以前的扩展方法博客贴子里，我演示了你如何可以象下面这样声明一个简单的Person类：

然后，我示范了你可以如何使用一些值来生成一个List<Person>集合的实例，然后使用由LINQ提供的新的Where和Average扩展方法来返回集合中的人的一个子集，以及计算这个集合中的人的平均年龄：

在上面list<Person>的集合的实例中是使用泛型的，它的实例化方式应该记住且应该特别的注意

List<Person> people = new List<Peson>{new Person{FirstNmae ="yuan",LastName ="Lei";age =24 },

                                                                new Person{FirstNmae ="yuan",LastName ="Lei";age =24 }  };

与一般的实例化有所不同！

上面高亮标记的红色 p => 表达式就是Lambda表达式。在上面的例子里，我用第一个lambda来指定获取特定人时所用的过滤条件，用第二个lambda来指定在计算平均年龄时该用Person对象的哪个值。

详解Lambda表达式

理解Lambda表达式最容易的方法是把它们设想成编写简明的行内方法的方式。譬如，我上面编写的例子可以使用C#2.0的匿名方法来编写，象这样：

上 面两个匿名方法都接受一个Person类型的参数。第一个匿名方法返回一个布尔值，表示Person的LastName是否是Guthrie，第二个匿名 方法返回一个整数值（返回那个人的年龄）。我们前面使用的lambda表达式的作用是一样的，两个表达式都接受一个Person类型的参数。第一个 lambda表达式返回一个布尔值，第二个返回一个整数。

在C#里，一个lambda表达式在句法上是写成一个参数列表，随后是 => 符号，随后是表达式在调用时要运算的表达式或者语句块：

params => expression

所以，当我们编写这样的lambda表达式时： 

p => p.LastName == "Guthrie"

我们是想表示，我们在定义的Lambda接受一个参数p，要运行的代码表达式返回p.LastName的值是否等于“Guthrie”。 我们将参数命名为p是不相干的，我也可以很容易地将其命名为o，x，foo，或者我想要的任何名字。

不 象匿名方法要求参数类型是明确地指明的，Lambda表达式允许省略参数类型，而允许它们根据用法来推断出类型。譬如，当我编写 p=>p.LastName == "Guthrie" 这个lambda表达式时，编译器推断出p参数属于Person类型，因为当前的Where扩展方法的对象people是个范型的 List<Person>集合。

IEnumerable<person> result =people.where( p=>p.lastName =="Lei" )的目的是从中 选择出满足要求的person类对象。其中IEnumerable是接口类在其对象result中存放person类型的对象，该对象是从 List<person>集合对象people中选取的。people中的每一个元素都是person类型的，输入参数P的值是person 类型的是从people中迭代出来的，Lambda表达式的作用是作为where的判断条件。

Lambda参数的类型可以在编译时和被Visual Studio的intellisense引擎推断出来，这意味着在编写lambda时你将获得完全的intellisense 和编译时检查。譬如，注意当我在下面健入 p.  时，Visual Studio Orcas是如何提供intellisense完成的，因为它知道 p 是 Person类型：

注: 假如你要给一个Lambda表达式明确地声明参数的类型的话，你可以在Lambda参数表里的参数名字前声明参数类型，象这样：

针对框架开发人员的高级内容：Lambda表达式树 (Lambda Expression Trees)

从 一个框架开发人员(framework developer)的角度来看，使得Lambda表达式特别强有力的事情之一是，它们既可以以基于IL的方法的形式被编译成代码代理（code delegate），或者也可以编译成一个表达式树(expression tree)对象，然后在运行时用来分析，转换或者优化表达式。

能将Lambda表达式编译成一个表达式树对象是个强大无比的机制，将促成许多使用场景，包括使用能提供编译时句法检查和VS intellisense的统一的查询语言来建立支持丰富数据查询的高性能对象映射器（无论是关系数据库，活动目录，还是web服务）之能力。

从Lambda表达式到代码代理 (Code Delegates)

上 面的Where扩展方法是个将Lambda表达式编译成代码代理(code delegate)的例子（意即它是编译成IL的，可以以代理的形式调用）。支持象上面那样过滤任何IEnumerable集合的Where()扩展方法 可以使用下面这样的扩展方法代码来实现：

上面的Where()扩展方法接受一个 Func<T, bool> 类型的过滤参数，该参数是个接受一个类型为T的参数，返回一个布尔值表示条件是否满足的方法之代理。当我们把Lambda表达式作为一个参数传递给这个 Where() 扩展方法时，C#编译器会将我们的Lambda表达式编译成IL方法代理（这里，<T> 将是Person），然后我们的Where()方法可以调用来计算某个给定条件是否被满足了。

从Lambda表达式到表达式树

当我们要想针对类似我们的列表集合一样的内存中的数据做运算时，把lambda表达式编译成代码代理是恰如其分的。但考虑一下你想要查询数据库里的数据的情形(下面的代码是使用Orcas中内置的LINQ到SQL对象关系映射器写成的) :

这里，我要从数据库里取出一串强类型的Product对象，我向Where()扩展方法表示，要通过一个Lambda表达式来做过滤。

我绝对不想 要看到发生的是，从数据库里取回所有的产品记录，将它们放在一个局部的集合里，然后在内存里对它运行Where()扩展方法来进行过滤。这么做效率极其不 高，对大数据库的扩缩性将是极差的。而我希望的是，LINQ到SQL的ORM将我上面的Lambda过滤条件翻译成SQL表达式，然后在远程的数据库里进 行过滤性查询。那样的话，我只返回那些符合查询条件的记录，这样的数据库查询效率是非常高的。

框架开发人员可以通过声明他们的Lambda表达式参数是个Expression<T>类型，而不是Func<T>类型来取得这样的结果。这会导致Lambda表达式参数被编译成一个我们可以在运行时拆开和分析的表达式树：

注意上面我是怎么把我们在先前用过的同样的 p=>p.LastName == "Guthrie" Lambda表达式，但这次将其赋值给一个 Expression<Func<Person, bool>> 变量，而不是Func<Person,bool> 变量。编译器不会产生IL，而是会指派一个表达式树对象，然后我作为一个框架开发人员就可以用它来对相应的Lambda表达式进行分析，按我想要的方式对其进行运算(譬如，我可以挑出表达式中的类型，名字和值等)。

在LINQ到SQL的情形下，它会将这个Lambda过滤语句翻译成标准的关系SQL语句，来对数据库进行操作(从逻辑上来说，一个“SELECT * from Products where UnitPrice < 55”语句)。

IQueryable<T> 接口

为 帮助框架开发人员建立可查询的数据提供器，LINQ提供了 IQueryable<T> 接口。这个接口实现了标准的LINQ扩展方法查询运算符，提供了一个更便利的方式来实现对一个复杂的表达式树的处理(譬如，象下面这样，我用了3个不同的 扩展方法，2个lambda来从数据库取回10个产品的情形)：