Lambda表达式(2)

Lambda表达式转换

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

l         DL具有相同数量的参数;

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

l         如果L具有隐式类型的参数列表,则D中不能有refout参数;

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<intdouble> f2 = x => x + 1;

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

 来看如下代码,如果这样赋值会怎么样?

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

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

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

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

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

类型推断

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

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

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

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

l         PL具有相同数量的参数,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的属性NameSelect方法可以用于从一个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参数的返回值类型,因此推断Sstring。因此,这个调用等价于:

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参数,推断Xstring。然后,第一个Lambda表达式的参数s具有推断出来的类型string,表达式TimeSpan.Parses)被关联到f1的返回值类型,推断YSystem.TimeSpan。最后,第二个Lambda表达式的参数t具有推断出来的类型System.TimeSpan,并且表达式t.TotalSeconds被关联到f2的返回值类型,推断Zdouble。因此这个调用的结果类型是double

重载抉择

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

下面是新添加的规则:

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

表达式树

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

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

 using System.Linq.Expressions

// 代码

 Func<intint> f = x => x + 1;

 // 数据

 Expression<Func<intint>> e = x => x + 1;

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

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页