没有 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。

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

概述

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

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

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

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

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

匿名函数

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

有两种匿名函数：

Lambda 表达式
匿名方法

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 委托创建过程的发展：

View 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();
    }
}

运行结果：

View 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.

Lamda 表达式

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

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

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

创建委托，如下所示：

View Code

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

创建表达式树，如下所示：

View Code

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

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

Lambda 表达式

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

(input parameters) => expression

如下所示：

(x, y) => x == y

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

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

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

() => SomeMethod()

Lambda 语句

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

(input parameters) => {statement;}

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

View Code

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

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

带有标准查询运算符的 Lambda

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

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

例如，假设有以下委托类型：

View 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：

View 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 的整数：

View Code

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

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

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

View Code

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

Lambda 中的类型推理

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

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

View Code

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

Lambda 的一般规则如下：

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

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

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

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

如下所示，查询语法与方法语法：

View 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();
    }
}

运行结果：

View 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 表达式看起来将完全相同。

View 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();

运行结果：

View Code

4 scores are greater than 80
apple
mango
grape

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

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

View 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);
}

运行结果：

View Code

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

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

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

View 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());};
    }
}

匿名方法

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

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

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

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

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

View 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);
    }
}

运行结果：

View Code

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

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

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

View Code

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