没有 Lambda 演算何来匿名函数——匿名函数(匿名方法和Lambda)、委托、LINQ

三、查询集合

本文内容

  • 引入
  • 概述
  • 匿名函数
  •     Lambda 表达式
  •     匿名方法
  • 参看资料

    引入

本文在 VS 2008 环境下,阐述自己对 Lambda 表达式、匿名函数、委托和 LINQ
谈谈自己的理解。我对这个问题的思考,始于以下阶段:

  • 毕业刚参加工作时,使用 VS 2005 C#,它还没有 LINQ
    特性。那时的主要精力在后台代码,初步掌握了委托、泛型等,以及设计模式,并尝试编写
    JavaScript 代码,只是不太重视;
  • 之后,尤其是跳槽后,对 JavaScript、jQuery、Ajax
    、DOM、HTML、CSS产生了兴趣,发现它们类似 JSON
    的书写方式很有意思,那时已经使用 VS
    2008,也有这种方式,因此在实际项目中时不时地采用这种方式书写;
  • 期间,知道了
    LINQ,觉得不错,在很大程度上,接近自然语言,简化了代码逻辑和代码量;
  • 但问题是,这种书写方式除了跟之前(VS 2005 前)完全不同外,无论是
    JavaScript,还是
    C#,这种方式,可以在不定义变量,不定义函数名、形参和返回值类型等情况下使用,的确让人困惑;
  • 为了更好的理解这种书写方式,我学习了 JSON 的理论,之后是 Lambda
    表达式、LINQ。

往往,当你缺少某方面知识时,对一个问题的理解不可能深入。

 

1.找出List<Product>列表中符合特定条件的所有元素

概述

我们都知道,定义一个函数,要有名字,也许要有形参列表、返回值类型。即便是现在,也是如此。

而 Lambda 演算(Lambda
calculus),告诉程序员们,其实不然,定义函数可以没有名字,没有形参列表,没有返回值类型,什么都没有,只有函数体,一些表达式或是语句(现在知道这是基于
Lambda 的类型推理),这就是匿名函数。

另一方面——委托,委托相当于函数(方法)指针(事件是委托的特例),那么完全可以利用匿名函数简化委托。Lambda
表达式的理论基础是Lambda 演算(Alonzo Church, 1930)。

LINQ 就是基于 Lambda 表达式(匿名函数)、泛型和简化的委托。

本文的重点是从大的方面上了解 Lambda 表达式和其应用,而不是它的语法。

 

C#1.1 查询步骤:循环,if判断,打印

匿名函数

匿名函数是一个“内联(inline)”语句或表达式,可在需要委托类型的任何地方使用。可以使用匿名函数来初始化命名委托,或传递命名委托(而不是命名委托类型)作为方法参数。

有两种匿名函数:

  • Lambda 表达式
  • 匿名方法

product类

C# 中委托的发展

  • C# 1.0 中,通过用其他位置定义的方法显式初始化委托来创建委托的实例。
  • C# 2.0 引入了匿名方法(anonymous
    method)的概念,用匿名方法初始化委托,在委托中执行未命名的内联语句块。
  • C# 3.0 引入了 Lambda
    表达式,与匿名方法的概念类似,但更具表现力并且更简练。匿名方法和Lambda
    表达式统称为“匿名函数”。
  • 通常,针对 .NET Framework 3.5 及更高版本应使用 Lambda 表达式。

下面的示例演示了从 C# 1.0 到 C# 3.0 委托创建过程的发展:

88必发手机版官方网站 188必发手机版官方网站 2View Code

class Test
{
    delegate void TestDelegate(string s);
    static void M(string s)
    {
        Console.WriteLine(s);
    }

    static void Main(string[] args)
    {
        // C# 1.0: 最初的委托语法,用一个方法名初始化委托.
        TestDelegate testdelA = new TestDelegate(M);

        // C# 2.0: 用内联代码初始化委托,这个内联代码成为“匿名方法”.
        // 这个方法把一个字符串作为输入参数.
        TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };

        // C# 3.0: 用 Lambda 表达式初始化委托. 
        // Lambda 表达式也把一个字符串(x)作为输入参数.
        // 编译器可以推断 x 的数据类型.
        TestDelegate testDelC = (x) => { Console.WriteLine(x); };

        // 调用委托.
        testdelA("Hello. My name is M and I write lines.");
        testDelB("That's nothing. I'm anonymous and ");
        testDelC("I'm a famous author.");

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}

运行结果:

88必发手机版官方网站 388必发手机版官方网站 4View Code

Hello. My name is M and I write lines.
That's nothing. I'm anonymous and
I'm a famous author.
Press any key to exit.

 

88必发手机版官方网站 588必发手机版官方网站 6

Lamda 表达式

“Lambda
表达式”拓展了人们对函数的认识,简化了函数定义。而委托又是一个外部函数(方法)的指针,因此,也就简化了委托。

Lambda
表达式是一个匿名函数,包含表达式或语句,可用于创建委托或表达式树类型。

表达式都使用 Lambda 运算符
=>。运算符左边是输入参数(如果有),右边包含表达式或语句块。

创建委托,如下所示:

88必发手机版官方网站 788必发手机版官方网站 8View Code

delegate int del(int i);
static void Main(string[] args)
{
    del myDelegate = x => x * x;
    int j = myDelegate(5); // j = 25
}

创建表达式树,如下所示:

88必发手机版官方网站 988必发手机版官方网站 1088必发手机版官方网站,View Code

using System.Linq.Expressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Expression<del> myET = x => x * x; //
        }
    }
}

在基于方法的 LINQ 查询中,如 Where,Lambda
表达式作为标准查询运算符方法的参数。

 1 using System.Collections;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp1
 5 {
 6     [Description("Listing 1.01")]
 7     public class Product
 8     {
 9         string name;
10         public string Name
11         {
12             get { return name; }
13         }
14 
15         decimal price;
16         public decimal Price
17         {
18             get { return price; }
19         }
20 
21         public Product(string name, decimal price)
22         {
23             this.name = name;
24             this.price = price;
25         }
26 
27         public static ArrayList GetSampleProducts()
28         {
29             ArrayList list = new ArrayList();
30             list.Add(new Product("West Side Story", 9.99m));
31             list.Add(new Product("Assassins", 14.99m));
32             list.Add(new Product("Frogs", 13.99m));
33             list.Add(new Product("Sweeney Todd", 10.99m));
34             return list;
35         }
36 
37         public override string ToString()
38         {
39             return string.Format("{0}: {1}", name, price);
40         }
41     }
42 }

Lambda 表达式

运算符右边是“Lambda 表达式”。Lambda
表达式在构造表达式树时广泛使用。Lambda
表达式返回表达式的结果,采用以下基本形式:

(input parameters) => expression

如下所示:

(x, y) => x == y

有时,编译器难于或无法推断输入类型。此时可以显式指定类型:

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

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

() => SomeMethod()

View Code

Lambda 语句

Lambda 语句与 Lambda 表达式类似,只是语句括在大括号中:

(input parameters) => {statement;}

Lambda 语句的主体可以包含任意数量的语句。

88必发手机版官方网站 1188必发手机版官方网站 12View Code

delegate void TestDelegate(string s);
…
TestDelegate myDel = n => { string s = n + "" + "World"; Console.WriteLine(s); };
myDel("Hello");

像匿名方法一样,Lambda 语句无法用于创建表达式树。

ArrayListQuery类

带有标准查询运算符的 Lambda

许多标准查询运算符都具有输入参数,其类型是泛型委托的 Func<Of T,
TResult> 系列的其中之一。如Enumerable.Count 方法、Enumerable.Max
方法、Enumerable.Min 方法等等。

Func<Of T, TResult> 中的 “Of T”
表示输入参数的数量和类型;”TResult” 表示委托的返回类型。Func
委托对于应用在一组数据中每个元素非常有用。

例如,假设有以下委托类型:

88必发手机版官方网站 1388必发手机版官方网站 14View Code

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:

88必发手机版官方网站 1588必发手机版官方网站 16View Code

Func<int, bool> myFunc = x => x == 5;
bool result = myFunc(4);

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

如下所示,演示一个标准查询运算符 Count 方法,计算整数 (n) 除以 2 余数为
1 的整数:

88必发手机版官方网站 1788必发手机版官方网站 18View Code

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

编译器可以推断输入参数的类型,或者您也可以显式指定该类型。

如下所示,演示返回数组 9 左边的所有元素,因为 9
是序列中不满足条件的第一个数字:

88必发手机版官方网站 1988必发手机版官方网站 20View Code

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

88必发手机版官方网站 2188必发手机版官方网站 22

Lambda 中的类型推理

在编写 Lambda 时,通常不必为输入参数指定类型,因为编译器可以根据 Lambda
主体、基础委托类型以及 C# 语言规范中描述的其他因素推断类型。

对于大多数标准查询运算符,第一个输入是源序列中元素的类型。因此,如果要查询
IEnumerable<Customer>,则输入变量将被推断为 Customer
对象,因此你可以访问其方法和属性:

88必发手机版官方网站 2388必发手机版官方网站 24View Code

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

Lambda 的一般规则如下:

  • Lambda 包含的参数数量必须与委托类型包含的参数数量相同。
  • Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。
  • Lambda 的返回值(如果有)必须能够隐式转换为委托的返回类型。

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

 1 using System;
 2 using System.Collections;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp1
 6 {
 7     [Description("Listing 1.10")]
 8     class ArrayListQuery
 9     {
10         static void Main()
11         {
12             ArrayList products = Product.GetSampleProducts();
13             foreach (Product product in products)
14             {
15                 if (product.Price > 10m)
16                 {
17                     Console.WriteLine(product);
18                 }
19             }
20         }
21     }
22 }

如何:在查询中使用 Lambda 表达式

不会在查询语法中直接用到 Lambda
表达式,但会在方法调用中用到,并且查询表达式(查询语法)可以包含方法调用(方法语法)。事实上,某些查询操作只能用方法语法表示。

如下所示,查询语法与方法语法:

88必发手机版官方网站 2588必发手机版官方网站 26View Code

class QueryVMethodSyntax
{
    static void Main()
    {
        int[] numbers = { 5, 10, 8, 3, 6, 12};

        // 查询语法:
        IEnumerable<int> numQuery1 = 
            from num in numbers
            where num % 2 == 0
            orderby num
            select num;

        // 方法语法:
        IEnumerable<int> numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n => n);

        foreach (int i in numQuery1)
        {
            Console.Write(i + "");
        }
        Console.WriteLine(System.Environment.NewLine);
        foreach (int i in numQuery2)
        {
            Console.Write(i + "");
        }

        // Keep the console open in debug mode.
        Console.WriteLine(System.Environment.NewLine);
        Console.WriteLine("Press any key to exit");
        Console.ReadKey();
    }
}

运行结果:

88必发手机版官方网站 2788必发手机版官方网站 28View Code

6 8 10 12
6 8 10 12

示例1:演示使用标准查询运算符 Enumerable.Where,基于方法语法(Lambda
表达式)查询。注意,示例中的 Where 方法具有一个委托类型为
Func<TSource, Boolean>
的输入参数,委托采用整数作为输入,并返回布尔值。可以将 Lambda
表达式转换为该委托。若是 Queryable.Where 方法(LINQ to SQL
查询),则参数类型为 Expression<Func<int,bool>>,但 Lambda
表达式看起来将完全相同。

88必发手机版官方网站 2988必发手机版官方网站 30View Code

// Enumerable.Where
// The call to Count forces iteration of the source
int[] scores = { 90, 71, 82, 93, 75, 82 };
int highScoreCount = scores.Where(n => n > 80).Count();
Console.WriteLine("{0} scores are greater than 80", highScoreCount);

// Queryable.Where
// Get all strings whose length is less than 6.
List<string> fruits = new List<string> { "apple", "passionfruit", "banana", "mango", 
           "orange", "blueberry", "grape", "strawberry" };
IEnumerable<string> query = fruits.AsQueryable().Where(fruit => fruit.Length < 6);
foreach (string fruit in query)
    Console.WriteLine(fruit);

Console.ReadKey();

运行结果:

88必发手机版官方网站 3188必发手机版官方网站 32View Code

4 scores are greater than 80
apple
mango
grape

示例2:演示在查询语法中使用方法语法(Lambda 表达式)。Lambda
是必需的,因为无法使用查询语法来调用 Sum 标准查询运算符。

查询首先按 GradeLevel
枚举中定义的方式,依据学生的成绩等级分组。然后,对每个组,添加每个学生的总分。这需要两个
Sum 运算。内部的 Sum 计算每名学生的总分,外部的 Sum
保留该组中所有学生的运行合并总计。

88必发手机版官方网站 3388必发手机版官方网站 34View Code

// This query retrieves the total scores for First Year students, Second Years, and so on.
// The outer Sum method uses a lambda in order to specify which numbers to add together.
var categories =
from student in students
group student by student.Year into studentGroup
select new { GradeLevel = studentGroup.Key, TotalScore = studentGroup.Sum(s => s.ExamScores.Sum()) };

// Execute the query.
foreach (var cat in categories)
{
      Console.WriteLine("Key = {0} Sum = {1}", cat.GradeLevel, cat.TotalScore);
}

运行结果:

88必发手机版官方网站 3588必发手机版官方网站 36View Code

Key = SecondYear Sum = 1014
Key = ThirdYear Sum = 964
Key = FirstYear Sum = 1058
Key = FourthYear Sum = 974

View Code

如何:在 LINQ 外部使用 Lambda 表达式

Lambda 表达式并不只限于在 LINQ
查询中使用。可以使用在需要委托值的任何地方(也就是在可以使用匿名方法的任何地方)。下面演示如何在
Windows 窗体事件处理程序中使用 Lambda 表达式。注意,输入的类型(Object
和 MouseEventArgs)由编译器推理,因此不必在 Lambda 输入参数中显式给定。

88必发手机版官方网站 3788必发手机版官方网站 38View Code

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        // Use a lambda expression to define an event handler.
       this.Click += (s, e) => { MessageBox.Show(((MouseEventArgs)e).Location.ToString());};
    }
}

2.测试和打印分开

 

C#2.0

匿名方法

虽然先有的匿名方法,后有的 Lambda 表达式,但仍然在 Lambda
后说明匿名方法。

在 2.0 之前的 C#
版本中,声明委托的唯一方法是使用命名方法(也就是用方法名初始化委托)。C#
2.0 引入了匿名方法,而在 C# 3.0 及更高版本中,Lambda
表达式取代了匿名方法,作为编写内联代码的首选方式。

不过,本节有关匿名方法的信息同样适用于 Lambda
表达式。有一种情况,匿名方法提供了 Lambda
表达式中所没有的功能。匿名方法使您能够省略参数列表,这意味着可以将匿名方法转换为带有各种签名的委托。这对于
Lambda 表达式来说是不可能的。

下面演示实例化委托的两种方法,都会在调用委托时显示一条消息:

  • 使委托与匿名方法关联。
  • 使委托与命名方法 (DoWork) 关联。

88必发手机版官方网站 3988必发手机版官方网站 40View Code

// Declare a delegate
delegate void Printer(string s);

class TestClass
{
    static void Main()
    {
        // Instatiate the delegate type using an anonymous method:
        Printer p = delegate(string j)
        {
            System.Console.WriteLine(j);
        };

        // Results from the anonymous delegate call:
        p("The delegate using the anonymous method is called.");

        // The delegate instantiation using a named method "DoWork":
        p = new Printer(TestClass.DoWork);

        // Results from the old style delegate call:
        p("The delegate using the named method is called.");
    }

    // The method associated with the named delegate:
    static void DoWork(string k)
    {
        System.Console.WriteLine(k);
    }
}

运行结果:

88必发手机版官方网站 4188必发手机版官方网站 42View Code

The delegate using the anonymous method is called.
The delegate using the named method is called.

通过使用匿名方法,不必创建单独的方法,减少了实例化委托所需的编码系统开销。

例如,如果创建方法所需的系统开销是不必要的,则指定代码块(而不是委托)可能非常有用。启动新线程即是一个很好的示例。无需为委托创建更多方法,线程类即可创建一个线程并且包含该线程执行的代码。

88必发手机版官方网站 4388必发手机版官方网站 44View Code

void StartThread()
{
    System.Threading.Thread t1 = new System.Threading.Thread
      (delegate()
            {
                System.Console.Write("Hello, ");
                System.Console.WriteLine("World!");
            });
    t1.Start();
}

 

product类

参考资料

Wiki Lambda 表达式 http://en.wikipedia.org/wiki/Lambda_calculus

MSDN 匿名函数 http://msdn.microsoft.com/zh-cn/library/bb882516.aspx

MSDN 委托Func<Of T, TResult>
http://msdn.microsoft.com/zh-cn/library/bb549151.aspx

MSDN 表达式树Expression<Func>
http://msdn.microsoft.com/zh-cn/library/system.linq.expressions.expression.aspx

System.Linq.Enumerable 类
http://msdn.microsoft.com/zh-cn/library/system.linq.enumerable(v=VS.90).aspx

System.Linq.Queryable 类
http://msdn.microsoft.com/zh-cn/library/bb293129(v=VS.90).aspx

Good Math, Bad Math 关于Lambda 阐述
http://scienceblogs.com/goodmath/goodmath/lambda_calculus/

 

Alonzo Church 1936
论文下载

88必发手机版官方网站 4588必发手机版官方网站 46

 1 using System.Collections.Generic;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp2
 5 {
 6     [Description("Listing 1.02")]
 7     public class Product
 8     {
 9         string name;
10         public string Name
11         {
12             get { return name; }
13             private set { name = value; }
14         }
15 
16         decimal price;
17         public decimal Price
18         {
19             get { return price; }
20             private set { price = value; }
21         }
22 
23         public Product(string name, decimal price)
24         {
25             Name = name;
26             Price = price;
27         }
28 
29         public static List<Product> GetSampleProducts()
30         {
31             List<Product> list = new List<Product>();
32             list.Add(new Product("West Side Story", 9.99m));
33             list.Add(new Product("Assassins", 14.99m));
34             list.Add(new Product("Frogs", 13.99m));
35             list.Add(new Product("Sweeney Todd", 10.99m));
36             return list;
37         }
38 
39         public override string ToString()
40         {
41             return string.Format("{0}: {1}", name, price);
42         }
43     }
44 }

View Code

ListQueryWithDelegates类

88必发手机版官方网站 4788必发手机版官方网站 48

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp2
 6 {
 7     [Description("Listing 1.11")]
 8     class ListQueryWithDelegates
 9     {
10         static void Main()
11         {
12             List<Product> products = Product.GetSampleProducts();
13             Predicate<Product> test = delegate(Product p)
14                 { return p.Price > 10m; };
15             List<Product> matches = products.FindAll(test);
16 
17             Action<Product> print = Console.WriteLine;
18             matches.ForEach(print);
19         }
20     }
21 }

View Code

变量test的初始化使用了匿名方法,而print变量的初始化使用了方法组转换,它简化了从现有方法创建委托的过程。不仅简单而且强大!

ListQueryWithDelegatesCompact类

88必发手机版官方网站 4988必发手机版官方网站 50

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp2
 6 {
 7     [Description("Listing 1.12")]
 8     class ListQueryWithDelegatesCompact
 9     {
10         static void Main()
11         {
12             List<Product> products = Product.GetSampleProducts();
13             products.FindAll(delegate(Product p) { return p.Price > 10; })
14                     .ForEach(delegate(Product p) { Console.WriteLine(p); });
15         }
16     }
17 }

View Code

3.用lambda表达式来测试

C#3.0

product

88必发手机版官方网站 5188必发手机版官方网站 52

 1 using System.Collections.Generic;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp3
 5 {
 6     [Description("Listing 1.3")]
 7     class Product
 8     {
 9         public string Name { get; private set; }
10         public decimal Price { get; private set; }
11 
12         public Product(string name, decimal price)
13         {
14             Name = name;
15             Price = price;
16         }
17 
18         Product()
19         {
20         }
21 
22         public static List<Product> GetSampleProducts()
23         {
24             return new List<Product>
25             {
26                 new Product { Name="West Side Story", Price = 9.99m },
27                 new Product { Name="Assassins", Price=14.99m },
28                 new Product { Name="Frogs", Price=13.99m },
29                 new Product { Name="Sweeney Todd", Price=10.99m}
30             };
31         }
32 
33         public override string ToString()
34         {
35             return string.Format("{0}: {1}", Name, Price);
36         }
37     }
38 }

View Code

ListQueryWithLambdaExpression类

88必发手机版官方网站 5388必发手机版官方网站 54

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 using System.Linq;
 5 
 6 namespace Chapter01.CSharp3
 7 {
 8     [Description("Listing 1.13")]
 9     class ListQueryWithLambdaExpression
10     {
11         static void Main()
12         {
13             List<Product> products = Product.GetSampleProducts();
14             foreach (Product product in products.Where(p => p.Price > 10))
15             {
16                 Console.WriteLine(product);
17             }
18         }
19     }
20 }

View Code

总结:

→C#1,条件和操作紧密耦合两者都是硬编码的

→C#2,条件和操作分开,匿名方法使委托变得简单(匿名方法有助于问题的可分离性)

→C#3Lambda表达式使条件变得更容易阅读(Lambda表达式增强了可读性)。