当前位置: 4166金沙 > 首页 > 正文

拉姆达表达式,肩托支架5D2

时间:2019-12-30 17:41来源:首页
配置参数 特色: 麦力/maili 斯坦尼康背心 稳定器 手持减震器 肩托支架5D2 5D3 查看完整参数       前面复习了"隐式类型局部变量","扩展方法","对象和集合初始化器","匿名方法"知识点

配置参数

  • 特色:麦力/maili 斯坦尼康背心 稳定器 手持减震器 肩托支架5D2 5D3

查看完整参数>>

      前面复习了"隐式类型局部变量","扩展方法","对象和集合初始化器","匿名方法"知识点。见C# 3.0语言增强学习笔记(一)

原文:《C# Version 3.0 Specification》,Microsoft
翻译:lover_P
C# 2.0中引入了匿名方法,允许在期望出现委托的时候以“内联(in-line)”的代码替代之。尽管匿名方法提供了函数式编程语言中的很多表达能力,但匿名方法的语法实在是太罗嗦了,并且很不自然。拉姆达表达式(Lambda expressions)为书写匿名方法提供了一种更加简单、更加函数化的语法。

这里我们另外复习C# 3.0的其他新特性:Lambda表达式

拉姆达表达式的书写方式是一个参数列表后跟=>记号,然后跟一个表达式或一个语句块。

初识Lambda表达式:

expression:
assignment
non-assignment-expression

使用C# 2.0中的匿名方法查找"内部包含abc子串的所有字符串": 

non-assignment-expression:
conditional-expression
lambda-expression
query-expression

List.FindAll(
      delegate(string s){
      return s.Indexof("abc")>0}
)

lambda-expression:
(  lambda-parameter-listopt  )  =>  lambda-expression-body
implicitly-typed-lambda-parameter  =>  lambda-expression-body

 使用C# 3.0中的Lambda表达式查找"内部包含abc子串的所有字符串":

lambda-parameter-list:
explicitly-typed-lambda-parameter-list
implicitly-typed-lambda-parameter-list

List.FindAll(s=>s.IndexOf("abc")>0)

explicitly-typed-lambda-parameter-list:
explicitly-typed-lambda-parameter
explicitly-typed-lambda-parameter-list  ,  explicitly-typed-lambda-parameter

 

explicitly-typed-lambda-parameter:
parameter-modifieropt  type  identifier

Lambda表达式简介

implicitly-typed-lambda-parameter-list:
implicitly-typed-lambda-parameter
implicitly-typed-lambda-parameter-list  ,  implicitly-typed-lambda-parameter

为什么Lambda表达式比匿名方法更好?

implicitly-typed-lambda-parameter:
identifier

C# 2.0的匿名方法允许我们以内联的方式来实现委托实例,而C# 3.0的Lambda表达式运行我们使用一种更接近人的思维,更自然的方式来实现类似于匿名方法同样的效果。

lambda-expression-body:
expression
block

Lambda表达式格式

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

(参数列表)=>表达式或者语句块

当拉姆达表达式只有一个具有隐式类型的参数时,参数列表中的括号可以省略。换句话说,下面这种形式的拉姆达表达式:

可以有多个参数,一个参数,或者无参数。参数类型可以隐式或者显式。例如:

(  param  )  =>  expr

(x,y)=>x*y //多参数,隐式类型=>表达式
拉姆达表达式,肩托支架5D2。x=>x*10 //单参数,隐式类型=>表达式
x=>{return x*10} //单参数,隐式类型=>语句块
(int x) => x*10 //单参数,显式类型=>表达式
(int x) =>{return x*10} //单参数,显示类型=>语句块
()=>{Console.WriteLine()}//无参数

可以简写为:

注意:

param  =>  expr

1.Lambda表达式的参数类型可以省略,因为可以根据使用上下文进行推测。

下面给出的是拉姆达表达式的一些例子:

2.Lambda表达式的主体(body)可以是表达式,也可以是语句块。

x => x + 1                         // 隐式类型,以表达式作为拉姆达表达式体

3.Lambda表达式传入的实参将参与类型推断,以及方法重载辨析。

x => { return x + 1; }          // 显式类型,以语句块作为拉姆达表达式体

4.Lambda表达式表达式和表达式体可以被转换成表达式树。

(int x) => x + 1                 // 显式类型,以表达式作为拉姆达表达式体

 

(int x) => { return x + 1; }  // 显式类型,以语句块作为拉姆达表达式体

Lambda表达式与委托类型

(x, y) => x * y                  // 多个参数

Lambda表达式L可以被转换成委托类型D,需要满足以下条件:

() => Console.WriteLine()      // 没有参数

1.L和D拥有相同的参数个数

通常,C# 2.0规范中提到的匿名方法规范同样适用于拉姆达表达式。拉姆达表达式是匿名方法在功能行上的超集,提供了下列附加的功能:

2.L参数类型要与D参数类型相同。注意隐式类型要参与类型辨析。

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

3.D的返回类型与L相同,无论L是表达式,还是语句块。

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

 

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

 

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

注意

PDC 2005技术预览版编译器并不支持以一个语句块作为表达式体的拉姆达表达式。当必需一个语句块时,请使用C# 2.0中的匿名方法语法。

3.1 拉姆达表达式转换

和匿名方法表达式类似,拉姆达表达式可以归类为一种拥有特定转换规则的值。这种值没有类型,但可以被隐式地转换为一个兼容的委托类型。特别地,当满足下列条件时,委托类型D兼容于拉姆达表达式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的返回值类型。

后面的例子将使用一个范型委托Func,表示一个函数,它具有一个类型为A的参数,返回值类型为R:

delegate R Func(A arg,',',');

在下面的赋值中:

Func f1 = x => x + 1;           // Ok

Func f2 = x => x + 1;        // Ok

Func f3 = x => x + 1;        // Error

每个拉姆达表达式的参数和返回值类型通过将拉姆达达表达式赋给的变量的类型来检测。第一个赋值将拉姆达表达式成功地转换为了委托类型Func,因为x的类型是int,x + 1是一个有效的表达式,并且可以被隐式地转换为int。同样,第二个赋值成功地将拉姆达表达式转换为了委托类型Func,因为x + 1的结果(类型为int)可以被隐式地转换为double类型。然而,第三个赋值将会产生一个编译期错误,因为x给定的类型是double,x

  • 1的结果(类型为double)不能被隐式地转换为int。

3.2 类型推断

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

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

l          参数是一个拉姆达表达式,以后简称为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推断出的返回值类型来从其上进行推断的,并且新的推断将被添加到累积的推断集合中。这个过程一直重复,直到无法进行更多的推断为止。

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

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

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

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

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

namespace System.Query

{

    public static class Sequence

    {

        public static IEnumerable Select(

            this IEnumerable source,

            Func selector)

        {

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

        }

    }

}

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

List customers = GetCustomerList(,',',');

IEnumerable names = customers.Select(c => c.Name,',',');

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

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

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

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

并且其返回值类型为IEnumerable。

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

static Z F(X value, Func f1, Func f2) {

    return f2(f1(value),',',');

}

下面这个调用:

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

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

3.3 重载抉择

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

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

下面的例子讲解了这一规则。

class ItemList : List

{

    public int Sum(Func selector) {

        int sum = 0;

        foreach(T item in this) sum += selector(item,',',');

        return sum;

    }

 

金沙4166,    public double Sum(Func selector) {

        double sum = 0;

        foreach(T item in this) sum += selector(item,',',');

        return sum;

    }

}

ItemList有两个Sum方法。每个都带有一个selector参数,用于从列表项目中依次选取值进行求和。选择的值或者是int或者是double,结果也相应的是int或double。

可以使用Sum方法来根据一份产品明细表对一个订单进行求和:

class Detail

{

    public int UnitCount;

    public double UnitPrice;

    ...

}

 

void ComputeSums() {

    ItemList orderDetails = GetOrderDetails(...,',',');

    int totalUnits = orderDetails.Sum(d => d.UnitCount,',',');

    double orderTotal = orderDetails.Sum(d => d.UnitPrice * d.UnitCount,',',');

    ...

}

在对orderDetails.Sum的第一个调用中,两个Sum方法都是可以的,因为拉姆达表达式d => d.UnitCount与Func和Func都兼容。然而,重载抉择选用了第一个Sum方法,因为转换到Func要优于转换到Func。

在对orderDetails.Sum的第二个调用中,只有第二个Sum方法是可用的,因为拉姆达表达式d => d.UnitPrice * d.UnitCount产生的值的类型是double。因此重载抉择选用第二个Sum方法进行调用。

 

编辑:首页 本文来源:拉姆达表达式,肩托支架5D2

关键词: