Lamda Expression

Posted everest7

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Lamda Expression相关的知识,希望对你有一定的参考价值。

ambda表达式的书写方式是一个参数列表后跟“=>”记号,然后跟一个表达式或一个语句块,即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);

            }

        }

    }

 

以上是关于Lamda Expression的主要内容,如果未能解决你的问题,请参考以下文章

Lamda groupingBy

Lamda groupingBy

Lamda Expression

java笔记:Lamda 表达式

AI 界著名“嘴炮”发声:鬼扯,LaMDA 不可能觉醒!

Java1.8 ​lamda+方法引用 + 函数式接口