C#3.0语言新特性之Lambda表达式

C#3.0语言新特性之Lambda表达式 收藏

在 C#2.0中引入了匿名方法，允许在期望出现委托的时候以“内联”的代码替代之。尽管匿名方法提供了函数式编 程语言中的很多表达能力，但匿名方法的语法实在是太罗嗦了，并且很不自然。 Lambda表达式为书写匿名方法提供了一种更加简单、更加函数化的语法。

实际上 Lambda表达式的本质是匿名方法，也即是当编译我们的程序代码时，编译器会自动帮我们将 Lambda表达式转换为匿名方法。

20.5.1 创建 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表达式是委托的实现方法，所以必须遵循以下规则：

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

l         如果委托的参数中包 括有 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();

        }

    }

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

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

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

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

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

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

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

20.5.2 Lambda表达式转换

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

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

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

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

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

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

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

l         如果 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。

20.5.3 类型推断

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

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

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

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

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

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

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

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

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

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

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

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

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

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。

20.5.4 重载抉择

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

下面是新添加的规则：

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

20.5.5 表达式树

表达式树允许将 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的数据结构。

public   class  LambdaExpressions
{
    public   int  ID {  get ;  set ; }
    public   string  Name {  get ;  set ; }

    public   void  LambdaExpressionsTest()
    {
        List<LambdaExpressions> list = new  List<LambdaExpressions>
        {
            new  LambdaExpressions { ID = 1, Name =  "zhaosoft"  },
            new  LambdaExpressions { ID = 2, Name =  "zhaosoft1"  },
            new  LambdaExpressions { ID = 3, Name =  "zhaosoft2"  }
        };

        IEnumerable<LambdaExpressions> l = list.Where(le => le.Name == "zhaosoft" );

        // 上面的（Lambda表达式）等同于下面的（匿名方法）

        // IEnumerable<LambdaExpressions> l2 = list.Where(delegate(LambdaExpressions le) { return le.Name == "webabcd"; });



        // 相关委托
        // public delegate TResult Func<T, TResult>(T arg);

        // 相关Where扩展方法
        // Func<TSource, bool>： 接受一个类型为TSource的参数
        // Func<TSource, bool>：某个需要满足的条件，返回bool值
        // public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        // {
        //     foreach (TSource item in source)
        //     {
        //         if (predicate(item))
        //         {
        //             yield return item;
        //         }
        //     }
        // }

    }
}