7. 委托、Lambda 和事件
在 2008 年的课程中,本章紧接在 Windows Forms 图形用户界面一章之后:事件首先在按钮和窗体的上下文中介绍,然后学生再学习如何在自己的类中创建事件。图形用户界面一章已从本版课程中删除。因此,我们直接从支撑整个机制的概念开始:委托,即引用一个或多个方法的对象。所有示例都是控制台程序。
在过去二十年中,委托已成为该语言中使用最广泛的工具之一。借助 Lambda 表达式 (C# 3),编写委托变得简单得多,我们在第 5 章用 LINQ 时已经用过它,只是没有深入细节:[Where(n => n > 5)] 把一个 Lambda(也就是一个委托)传递给方法 [Where]。本章解释这种语法背后的原理。本章最后讲解 事件,它们同样基于委托。.NET 的图形用户界面(Windows Forms、WPF、.NET MAUI)以及 Web 框架都基于这一机制:按钮点击或 HTTP 请求的到达会被通知给已订阅的方法。
本章的程序是位于 [07-delegates] 文件夹中的单文件应用程序。它们使用 [dotnet run delegates-NN.cs] 运行。
7.1. 预定义的委托类型
7.1.1. 委托的概念
委托类型 描述方法的一个模型(也称为原型或签名):其参数的类型和返回值的类型。委托类型的变量随后可以引用任何符合该模型的方法并执行它。
.NET 框架定义了许多委托类型。最古老的是 [EventHandler],本章末尾将讨论的所有事件都使用它。它的定义如下:
| public delegate void EventHandler(object? sender, EventArgs e);
|
关键字 [delegate] 使 [EventHandler] 成为委托类型。该类型表示一种方法模式:
- 其第一个参数是类型为 [object?] 的对象(触发事件的对象,可能为 [null]);
- 其第二个参数是类型为 [EventArgs] 的对象(有关事件的信息);
- 不返回任何结果([void])。
符合 [EventHandler] 所定义模型的方法可以如下:
| static void Display(object? sender, EventArgs e) { ... }
|
要创建引用该方法的 [EventHandler] 类型对象,可以这样写:
| EventHandler handler = new EventHandler(Display);
|
或者,更简单地:
| EventHandler handler = Display;
|
在第二种写法中,方法名 [Display] (一个 方法组,因为一个方法可以有多个重载)被编译器自动转换为 [EventHandler] 对象:这就是方法组转换,自 C# 2 起就已可行。编译器会从 [Display] 的各个重载中选择与委托签名相匹配的那一个。然后委托像方法一样被执行:[handler("program", EventArgs.Empty)]。
7.1.2. 泛型委托 Func、Action 和 Predicate
在泛型出现之前(C# 2),必须为每种方法签名定义一个委托类型。如今,框架提供了泛型委托类型,几乎可以满足所有需求:
委托类型 | 所引用的方法 |
[Action] | 无参数,无返回值:[void M()] |
[Action<T1, ..., T16>] | 1 到 16 个参数,无返回值:[void M(T1 p1, ...)] |
[Func<TResult>] | 无参数,有一个返回值:[TResult M()] |
[Func<T1, ..., T16, TResult>] | 1 到 16 个参数,返回值的类型为 [TResult] (始终是最后一个类型参数) |
[Predicate<T>] | 一个参数,返回布尔值:[bool M(T p)] |
[Comparison<T>] | 两个相同类型的参数,返回整数:[int M(T x, T y)] |
[Predicate<T>] 和 [Func<T, bool>] 描述的是同一个签名,但它们是两个不同的类型:[Predicate<T>] 诞生于 .NET 2,被 [List<T>] 和 [Array] 的方法([FindAll]、[RemoveAll]、[Exists]……)使用,而随 .NET 3.5 引入的 LINQ 则使用 [Func<T, bool>]。
程序 [delegates-01.cs] 使用了这些委托类型:
| // .NET 预定义的委托类型
// 1 - EventHandler 委托:void M(object? sender, EventArgs e)
EventHandler handler = new EventHandler(Display);
// 简写形式:方法组转换
handler = Display;
// 执行委托
handler("program", EventArgs.Empty);
// 2 - Func<T1, T2, TResult>:两个 int 参数,一个 int 结果
Func<int, int, int> operation = Add;
Console.WriteLine($"operation(2, 3)={operation(2, 3)}");
// Func<TResult>:无参数,一个结果
Func<string> greet = Greet;
Console.WriteLine($"greet()={greet()}");
// 3 - Action<T>:一个参数,无结果
Action<string> write = Console.WriteLine;
write("Action<string> executed Console.WriteLine");
// 4 - Predicate<T>:一个参数,返回 bool 结果
Predicate<int> isEven = IsEven;
List<int> numbers = [3, 8, 1, 6, 5, 4];
// List<T> 的 FindAll 和 RemoveAll 需要一个 Predicate<T>
Console.WriteLine($"even: {string.Join(" ", numbers.FindAll(isEven))}");
int nbRemoved = numbers.RemoveAll(IsEven);
Console.WriteLine($"{nbRemoved} even numbers removed, remaining: {string.Join(" ", numbers)}");
// 5 - Comparison<T>:两个 T 参数,返回 int 结果
List<string> names = ["Paul", "Mélanie", "Jo", "Sébastien"];
names.Sort(CompareLengths);
Console.WriteLine($"sorted by length: {string.Join(" ", names)}");
// 6 - 委托是一个对象:它的类型以及它引用的方法
Console.WriteLine($"type: {operation.GetType()}");
Console.WriteLine($"method: {operation.Method.Name}, target: {operation.Target?.ToString() ?? "none (static method)"}");
// 委托所引用的方法
static void Display(object? sender, EventArgs e)
{
Console.WriteLine($"Display(sender={sender}, e={e.GetType().Name})");
}
static int Add(int n1, int n2) => n1 + n2;
static string Greet() => "Hello";
static bool IsEven(int n) => n % 2 == 0;
static int CompareLengths(string s1, string s2) => s1.Length.CompareTo(s2.Length);
|
结果:
| > dotnet run delegates-01.cs
Display(sender=program, e=EventArgs)
operation(2, 3)=5
greet()=Hello
Action<string> executed Console.WriteLine
even: 8 6 4
3 even numbers removed, remaining: 3 1 5
sorted by length: Jo Paul Mélanie Sébastien
type: System.Func`3[System.Int32,System.Int32,System.Int32]
method: <<Main>$>g__Add|0_1, target: none (static method)
|
说明:
- 第 4 行:使用运算符 [EventHandler] 创建委托 [new]。这是 C# 1 中必须使用的语法;
- 第 6 行:用方法组转换实现同样的功能。这是如今的标准语法;
- 第 8 行:委托像方法一样被执行。第 39 行的方法 [Display] 会被执行,参数即传给委托的参数;
- 第 11 行:[Func<int, int, int>] 引用一个有两个 [int] 参数、返回 [int] (最后一个泛型类型)的方法。第 44 行的方法 [Add] 符合要求;
- 第 14 行:[Func<string>] 引用一个无参数、返回字符串的方法;
- 第 18 行:[Action<string>] 引用一个有一个 [string] 参数且无返回值的方法。[Console.WriteLine] 有许多重载;编译器选择 [WriteLine(string)];
- 第 22 行:谓词(predicate)是返回布尔值的方法。类 [FindAll] 的方法 [List<T>] (第 25 行)需要一个 [Predicate<T>] 类型的参数:它返回使谓词返回 [true] 的所有元素组成的列表。第 26 行:方法名
[IsEven] 被直接传入;编译器将其转换为 *[Predicate<int>]*;
- 第 31 行:方法 [Sort] 接受一个 [Comparison<T>] 委托来比较两个元素(结果为负数、零或正数,与 [CompareTo] 相同)。这里,名称按长度升序排序;
- 第 35–36 行:委托是一个对象。其类型显示在结果的第 9 行,为 [System.Func`3[System.Int32,System.Int32,System.Int32]]:这是带有三个类型参数的泛型类型的技术名称。每个委托类型都派生自类 [System.Delegate],该类特别提供了属性 [Method] (所引用的方法)和 [Target](调用该方法所基于的对象,对于静态方法则为 [null]);
- 输出第 10 行中的方法名令人意外:第 39–50 行的方法是主程序的 局部函数 (参见第 3 章)。编译器会把它们转换为其生成的某个类的静态方法,该类的名称是任何 C# 程序都无法写出的。
7.2. 定义委托类型
预定义类型通常已经足够,但你也可以定义自己的委托类型。语句:
| public delegate int Operation(int n1, int n2);
|
定义了一个名为 [Operation] 的类型,它代表一个接受两个整数并返回一个整数的方法模板。与 [Func<int, int, int>] 相比,类型 [Operation] 的名称描述了其用途,其参数也有名称([n1]、[n2]),开发工具会显示这些名称。
类型为 [op] 的变量 [Operation] 用于存储与 [Operation] 模型相对应的方法 列表:这称为 多播委托。
- 类型为 [f] 的方法通过 [op = new Operation(f)] 或更简单的 [op = f] 存储到变量 [op]中;
- 要将方法 [g] 添加到已注册的方法列表中,写作 [op += g];
- 要移除已注册的方法 [h],写作 [op -= h];
- 语句 [n = op(n1, n2)] 会按注册顺序执行 [op] 中注册的所有方法,使用参数 [n1] 和 [n2]。返回的结果 [n] 是最后一个被执行的方法的结果。
2008 年的课程指出无法获得所有方法的结果。其实是可以的,但不能通过一次调用实现:必须遍历 [GetInvocationList] 返回的方法列表,并逐个调用。实际上,在多播委托中注册的方法大多返回 [void]。
来看示例 [delegates-02.cs]:
| // 定义自己的委托类型
// 我们定义一个 Operation 类型的对象,用来在其中注册方法
// 注册静态方法 Increase
Operation op = Calculations.Increase;
// 执行委托
int n = op(4, 7);
Console.WriteLine($"n={n}");
// 创建 Calculations 类型的对象 c1
var c1 = new Calculations();
// 把 c1 的 Add 方法注册到委托中
op = c1.Add;
// 执行委托对象
n = op(2, 3);
Console.WriteLine($"n={n}");
// 把 c1 的 Subtract 方法注册到委托中
op = c1.Subtract;
n = op(2, 3);
Console.WriteLine($"n={n}");
// 在委托中注册两个方法(多播委托)
op = c1.Add;
op += c1.Subtract;
// 执行委托对象:得到最后一个方法的结果
n = op(10, 4);
Console.WriteLine($"n={n}");
// 通过调用列表得到所有方法的结果
foreach (Operation method in op.GetInvocationList().Cast<Operation>())
{
Console.WriteLine($"{method.Method.Name} -> {method(10, 4)}");
}
// 从委托中移除一个方法:结果可能为 null(Operation? 类型)
Operation? rest = op - c1.Subtract;
// 如果委托不为 null,则执行它
if (rest is not null)
{
n = rest(1, 1);
Console.WriteLine($"n={n}");
}
// 移除最后一个方法:委托变为 null
Operation? empty = rest - c1.Add;
Console.WriteLine($"empty is null: {empty is null}");
// ?.Invoke 仅在委托不为 null 时执行它
Console.WriteLine($"empty?.Invoke(1, 1)={empty?.Invoke(1, 1)}");
// 一个类,其方法具有 Operation 委托的签名
public class Calculations
{
// 两个实例方法
public int Add(int n1, int n2)
{
Console.WriteLine($"Add({n1},{n2})");
return n1 + n2;
}
public int Subtract(int n1, int n2)
{
Console.WriteLine($"Subtract({n1},{n2})");
return n1 - n2;
}
// 一个静态方法
public static int Increase(int n1, int n2)
{
Console.WriteLine($"Increase({n1},{n2})");
return n1 + 2 * n2;
}
}
// 定义委托类型:一个方法模板
// 接受两个整数作为参数并返回一个整数
public delegate int Operation(int n1, int n2);
|
结果:
| > dotnet run delegates-02.cs
Increase(4,7)
n=18
Add(2,3)
n=5
Subtract(2,3)
n=-1
Add(10,4)
Subtract(10,4)
n=6
Add(10,4)
Add -> 14
Subtract(10,4)
Subtract -> 6
Add(1,1)
n=2
empty is null: True
empty?.Invoke(1, 1)=
|
说明:
- 第 73 行:定义委托类型 [Operation]。在采用顶级语句的应用程序中,类型声明(类、接口、委托等)放在主程序语句之后;
- 第 48–67 行:类 [Calculations] 有两个实例方法 [Add] 和 [Subtract],以及一个静态方法 [Increase],这三个方法都具有 [Operation] 类型的签名;
- 第 5 行:变量 [op] 的类型为 [Operation]。它被赋予第一个方法引用,即静态方法 [Calculations.Increase];
- 第 7 行:执行委托 [op]。[op] 引用的所有方法都会被执行,参数即传给 [op] 的参数。这里只有方法 [Calculations.Increase] 被执行;
- 第 11 行:创建类 [c1] 的实例 [Calculations] ;
- 第 13 行:将实例方法 [c1.Add] 赋给委托 [op]。[Increase] 是静态方法,[Add] 是实例方法:这没有关系。对于后者,委托还会存储将要在其上调用该方法的对象 [c1] (即其属性 [Target]);
- 第 18 行:对实例方法 [Subtract] 做同样的处理;
- 第 23–24 行:将两个方法 [Add] 和 [Subtract] 注册到委托 [op]中;
- 第 26 行:两个方法都被执行(结果的第 8–9 行)。得到的结果 6 是最后执行的方法 [Subtract] 的结果;
- 第 29–31 行:[GetInvocationList] 以数组 [Delegate[]] 的形式返回委托中的方法列表。LINQ 方法 [Cast<Operation>()] 将其每个元素转换为 [Operation],这样就可以逐个调用它们并获取每个结果;
- 第 34 行:从委托中移除方法
[Subtract]。写法 ***[op -= c1.Subtract] 等价于 ***[op = op - c1.Subtract]***。运算符 [-] 的结果类型为 [Operation?]:如果移除了委托中的最后一个方法,得到的是 [null]*,而不是空委托。跟踪可空类型的编译器(参见第 3 章),在你写 [op -= c1.Subtract] 并接着写 [op(1, 1)] 时会发出警告:[CS8601] 出现在将可能为 null 的值赋给不可为 null 的变量 [op] 时,[CS8602] 出现在调用该方法时。因此,我们把结果存储在类型为 [Operation?] 的变量中,并在执行之前对其进行检查(第 36 行);
- 第 42 行:移除最后一个方法;得到的委托为 [null] (结果的第 17 行);
- 第 45 行:委托也可以通过其方法 [Invoke] 来执行:[op(1, 1)] 和 [op.Invoke(1, 1)] 是等价的。借助 [?.] 运算符(C# 6),[empty?.Invoke(1, 1)] 仅在委托不为 [null] 时才执行它;否则表达式的值为 [null] ,不执行任何操作。字符串内插会将 [null] 呈现为空字符串。在讨论事件时我们还会再见到这种语法。
委托是 不可变对象:运算 [+] 和 [-] (因此还有 [+=] 和 [-=])并不修改现有的委托,而是创建一个新的委托。在处理事件时,这一特性将很重要。
7.3. 匿名方法和 Lambda 表达式
7.3.1. 从匿名方法到 Lambda
在前面的示例中,每个委托都引用程序中其他位置编写的具名方法。对于仅使用一次的简短方法,这样做很麻烦。C# 2 引入了 匿名方法:方法体就写在创建委托的地方。C# 3 引入了更简洁的语法——Lambda 表达式,它几乎取代了匿名方法。程序 [delegates-03.cs] 演示了各种形式:
| // 从匿名方法到 lambda 表达式
// 1 - 匿名方法(C# 2):方法体直接写在原地
Func<int, int, int> add = delegate (int n1, int n2)
{
return n1 + n2;
};
Console.WriteLine($"anonymous method: add(2, 3)={add(2, 3)}");
// 2 - 用 lambda 表达式(C# 3)实现同样的功能:参数 => 方法体
Func<int, int, int> subtract = (int n1, int n2) =>
{
return n1 - n2;
};
Console.WriteLine($"block-bodied lambda: subtract(2, 3)={subtract(2, 3)}");
// 3 - 参数类型由目标委托类型推断
Func<int, int, int> multiply = (n1, n2) => n1 * n2;
Console.WriteLine($"expression-bodied lambda: multiply(2, 3)={multiply(2, 3)}");
// 4 - 单个参数:括号可省略
Func<int, int> square = x => x * x;
Predicate<string> isEmpty = s => s.Length == 0;
Console.WriteLine($"square(7)={square(7)}, isEmpty(\"\")={isEmpty("")}");
// 5 - 无参数:使用空括号
Func<string> greet = () => "Hello";
Action beep = () => Console.WriteLine("beep!");
Console.WriteLine(greet());
beep();
// 6 - 包含多条语句的块体
Action<string, int> repeat = (text, times) =>
{
for (int i = 0; i < times; i++)
{
Console.Write(text);
}
Console.WriteLine();
};
repeat("ab", 3);
// 7 - 被忽略的参数(弃元):不需要它们的值
EventHandler handler = (_, _) => Console.WriteLine("event received");
handler(null, EventArgs.Empty);
// 8 - 直接把 lambda 作为方法的参数传入
List<int> numbers = [3, 8, 1, 6, 5, 4];
Console.WriteLine($"even: {string.Join(" ", numbers.FindAll(n => n % 2 == 0))}");
numbers.Sort((n1, n2) => n2.CompareTo(n1));
Console.WriteLine($"descending order: {string.Join(" ", numbers)}");
|
结果:
| > dotnet run delegates-03.cs
anonymous method: add(2, 3)=5
block-bodied lambda: subtract(2, 3)=-1
expression-bodied lambda: multiply(2, 3)=6
square(7)=49, isEmpty("")=True
Hello
beep!
ababab
event received
even: 8 6 4
descending order: 8 6 5 4 3 1
|
说明:
- 第 4–6 行:一个匿名方法。关键字 [delegate] 后面跟着参数列表和方法体。编译器会生成一个方法(名称由其自行选定),并创建引用该方法的委托 [Func<int, int, int>]。这里没有方法名,也没有返回类型:返回类型由 [return] 语句推断得出;
- 第 11–13 行:用 Lambda 表达式实现同样的功能。我们写出参数列表、[=>] 运算符(读作“得到”或“使得”),然后是方法体。方法体是用花括号括起来的语句块的 Lambda 称为 语句块 Lambda(statement lambda);
- 第 18 行:没有参数类型。编译器根据目标委托类型 [Func<int, int, int>] 推断出:[n1] 和 [n2] 的类型是 [int]。方法体简化为一个表达式,其值就是 Lambda 的结果:这是一个 表达式体 Lambda (lambda expression)。这是最常见的形式;
- 第 22 行:如果只有一个参数且未指定类型,括号可以省略。[x => x * x] 读作“x 得到 x 乘以 x”。第 23 行:同样是单参数 Lambda,参数类型为 [string],返回布尔值:它是一个 [Predicate<string>];
- 第 27–28 行:没有参数时,使用空括号。方法体为方法调用([void]) 的 Lambda 适用于委托([Action]);
- 第 33–39 行:语句块体的 Lambda 可以包含任意语句:声明、循环、测试等;
- 第 44 行:下划线字符 [_] 表示被忽略的参数(弃元,C# 9)。当委托的签名要求有参数而 Lambda 并不需要时使用,这在事件处理程序中很常见;
- 第 49 行:Lambda 最常见的用法是直接将其作为参数传给期望委托的方法。与 [delegates-01.cs] 比较:不再需要编写方法 [IsEven];
- 第 50 行:一个类型为 [Comparison<int>] 的 Lambda,它颠倒了通常的比较方式:列表按降序排序。
我们来回顾一下 Lambda 表达式的各种形式:
形式 | 示例 |
带类型的参数,语句块体 | [(int a, int b) => { return a + b; }] |
不带类型的参数,表达式体 | [(a, b) => a + b] |
单个不带类型的参数 | [x => x * x] |
无参数 | [() => "Hello"] |
忽略参数 | [(_, _) => Console.WriteLine("received")] |
参数要么全部带类型,要么全部不带类型:不能混用。在本课程中,我们将使用 Lambda 而不是匿名方法,匿名方法如今只在少数情况下才有用。
7.3.2. 更多关于 Lambda 的内容
较新版本的 C# 增强了 Lambda。程序 [delegates-04.cs] 演示了这些新特性:
| // lambda 表达式补充(C# 9 到 C# 14)
// 1 - lambda 的自然类型(C# 10):若参数有类型,可以使用 var
var twice = (int x) => x * 2;
Console.WriteLine($"twice(21)={twice(21)}, type: {Name(twice)}");
var display = (string s) => Console.WriteLine($"[{s}]");
display("Action<string>");
Console.WriteLine($"type of display: {Name(display)}");
// 如果方法组只有一个重载,它也具有自然类型
var isEven = IsEven;
Console.WriteLine($"isEven(4)={isEven(4)}, type: {Name(isEven)}");
// 2 - 显式返回类型(C# 10):在无法推断时很有用
var choose = object (bool b) => b ? 1 : "one";
Console.WriteLine($"choose(true)={choose(true)}, choose(false)={choose(false)}");
// 3 - 带默认值的参数(C# 12)
var greet = (string name, string greeting = "Hello") => $"{greeting} {name}";
Console.WriteLine(greet("Pierre"));
Console.WriteLine(greet("Pierre", "Good evening"));
// 以及 params
var sum = (params int[] values) => values.Sum();
Console.WriteLine($"sum()={sum()}, sum(1, 2, 3)={sum(1, 2, 3)}");
// 这些 lambda 的类型是编译器生成的匿名委托
Console.WriteLine($"type of greet: {Name(greet)}");
// 4 - 静态 lambda(C# 9):它不能使用任何局部变量,也不能使用 this
const int Coefficient = 3;
Func<int, int> triple = static x => x * Coefficient; // 允许使用常量
Console.WriteLine($"triple(5)={triple(5)}");
// 5 - 不带类型的 ref / out / in 修饰符(C# 14)
// Incrementer 委托类型已确定这些类型:lambda 无需重复写出
Incrementer increment = (ref x) => x++;
int counter = 10;
increment(ref counter);
increment(ref counter);
Console.WriteLine($"counter={counter}");
Parser parse = (text, out value) => int.TryParse(text, out value);
Console.WriteLine($"parse(\"12\"): {parse("12", out int v1)} {v1}");
Console.WriteLine($"parse(\"x\"): {parse("x", out int v2)} {v2}");
// 委托类型的可读名称:Func<Int32, Int32> 而不是 Func`2
static string Name(Delegate d)
{
Type t = d.GetType();
if (!t.IsGenericType)
{
return t.Name;
}
string name = t.Name[..t.Name.IndexOf('`')];
return $"{name}<{string.Join(", ", t.GetGenericArguments().Select(a => a.Name))}>";
}
static bool IsEven(int n) => n % 2 == 0;
// 带有 ref 和 out 参数的委托类型
delegate void Incrementer(ref int x);
delegate bool Parser(string text, out int value);
|
结果:
| > dotnet run delegates-04.cs
twice(21)=42, type: Func<Int32, Int32>
[Action<string>]
type of display: Action<String>
isEven(4)=True, type: Func<Int32, Boolean>
choose(true)=1, choose(false)=one
Hello Pierre
Good evening Pierre
sum()=0, sum(1, 2, 3)=6
type of greet: <>f__AnonymousDelegate0<String, String, String>
triple(5)=15
counter=12
parse("12"): True 12
parse("x"): False 0
|
说明:
- 第 4 行:在 C# 9 之前,Lambda 没有自己的类型:必须始终指定目标委托类型([Func<int, int> twice = x => x * 2])。自 C# 10 起,带类型参数的 Lambda 具有 自然类型:这里是 [Func<int, int>],如结果第 2 行所示。因此我们可以写 [var]。但是,[var twice = x => x * 2;] 会被编译器拒绝,因为它无法推断 [x] 的类型;
- 第 6 行:不返回任何值的 Lambda 的自然类型是 [Action<...>];
- 第 10 行:方法组也有自然类型,前提是只有一个同名方法。[var write = Console.WriteLine;] 会被拒绝:[WriteLine] 大约有二十个重载;
- 第 14 行:自 C# 10 起,可以在参数列表之前指定返回类型。这里必须这样做:条件运算符的两个分支类型不同([int] 和 [string]),编译器无法知道该选择哪个返回类型;
- 第 18 行:从 C# 12 开始,Lambda 的参数可以像方法参数一样拥有默认值。第 19–20 行分别带第二个参数和不带第二个参数调用该 Lambda;
- 第 22 行:同样,Lambda 的最后一个参数可以是 [params];
- 第 25 行:类型 [Func] 和 [Action] 都无法表示可选参数或 [params]。此时编译器会生成一个匿名委托类型,这里是 [<>f__AnonymousDelegate0] (结果的第 10 行)。它只能由 [var] 使用;
- 第 29 行:声明为 [static] 的 Lambda(C# 9)既不能使用外层方法的局部变量,也不能使用 [this]。它可以使用常量,例如第 28 行的 [Coefficient]。我们将在下一节说明“使用局部变量”意味着什么;关键字 [static] 确保 Lambda 不会捕获任何局部变量,从而避免内存分配和错误;
- 第 58 行:一个参数按引用传递([ref],参见第 3 章)的委托类型。类型 [Func] 和 [Action] 不允许有 [ref] 或 [out] 类型的参数:必须定义自己的委托类型;
- 第 34 行:在 C# 13 之前,如果 Lambda 的参数是 [ref]、[out] 或 [in],就必须显式为所有参数指定类型,如 [(ref int x) => x++]。从 C# 14 开始,只需修饰符即可,因为类型可由目标委托推断。第 36–37 行将变量 [counter] 递增两次;
- 第 39 行:对 [out] 参数做同样的处理。Lambda 将其 [out] 参数传给 [int.TryParse];
- 第 44–52 行:一个以可读格式显示泛型委托类型名称的实用函数(显示 [Func<Int32, Int32>] 而不是 [Func`2])。它本身在第 52 行也使用了 Lambda。
7.3.3. 变量捕获与闭包
Lambda 可以使用其所在方法的局部变量,这称为 捕获 这些变量。这个非常强大的机制有一些出人意料之处。程序 [delegates-05.cs] 突出展示了这些情况:
| // 变量捕获与闭包
// 1 - lambda 可以使用其周围的局部变量
int threshold = 5;
Func<int, bool> exceeds = n => n > threshold;
Console.WriteLine($"threshold={threshold}: exceeds(7)={exceeds(7)}");
// 被捕获的是变量而不是它的值:lambda 能看到该变量的修改
threshold = 10;
Console.WriteLine($"threshold={threshold}: exceeds(7)={exceeds(7)}");
// 2 - lambda 也可以修改被捕获的变量
int total = 0;
Action<int> accumulate = n => total += n;
accumulate(3);
accumulate(4);
Console.WriteLine($"total={total}");
// 3 - 闭包:被捕获的变量比创建它的方法活得更久
Func<int> counterA = CreateCounter();
Func<int> counterB = CreateCounter();
Console.WriteLine($"A: {counterA()} {counterA()} {counterA()}");
Console.WriteLine($"B: {counterB()} {counterB()}");
// 4 - for 循环中的捕获陷阱
List<Action> actions = [];
for (int i = 0; i < 3; i++)
{
// 三个 lambda 捕获的是同一个变量 i
actions.Add(() => Console.Write($"{i} "));
}
Console.Write("for, capture of i: ");
foreach (Action action in actions)
{
action();
}
Console.WriteLine();
// 修正方法:使用局部副本,每次循环迭代都是新的
actions.Clear();
for (int i = 0; i < 3; i++)
{
int copy = i;
actions.Add(() => Console.Write($"{copy} "));
}
Console.Write("for, capture of a copy: ");
actions.ForEach(action => action());
Console.WriteLine();
// foreach(自 C# 5 起)在每次迭代时创建一个新变量
actions.Clear();
foreach (int j in new[] { 0, 1, 2 })
{
actions.Add(() => Console.Write($"{j} "));
}
Console.Write("foreach: ");
actions.ForEach(action => action());
Console.WriteLine();
// 返回函数的方法
static Func<int> CreateCounter()
{
// 被返回的 lambda 捕获的局部变量
int value = 0;
return () => ++value;
}
|
结果:
| > dotnet run delegates-05.cs
threshold=5: exceeds(7)=True
threshold=10: exceeds(7)=False
total=7
A: 1 2 3
B: 1 2
for, capture of i: 3 3 3
for, capture of a copy: 0 1 2
foreach: 0 1 2
|
说明:
- 第 5 行:Lambda 使用了第 4 行声明的局部变量
[threshold]。[threshold] 不是 Lambda 的参数:它是一个被捕获的变量;
- 第 8 行:[threshold] 在 Lambda 创建 之后被修改。结果(第 2–3 行)表明 Lambda 看到了新值:[exceeds(7)] 先返回 [True] 再返回 [False]。Lambda 并没有在创建时复制 [threshold] 的值;它与外层方法共享 变量 本身;
- 第 13 行:Lambda 也可以修改被捕获的变量。在第 14–15 行的两次调用之后,变量 [total] 等于 7;
- 第 60–64 行:函数 [CreateCounter] 返回一个捕获其局部变量 [value] 的 Lambda。通常,局部变量在方法结束时就会消失。这里,变量 [value] 在 [CreateCounter] 结束后仍然存在,因为返回的 Lambda 仍在使用它。Lambda 与其所捕获的变量的组合称为闭包。为实现这一点,编译器将被捕获的变量转换为其生成的某个对象的字段,并将 Lambda 转换为该对象的方法;
- 第 19–20 行:每次调用 [CreateCounter] 都会创建一个新的变量 [value]——也就是一个新的计数器——它独立于其他计数器。结果(第 5–6 行)证实了这一点;
- 第 26–29 行:经典的陷阱。我们在 [for] 循环中创建三个 Lambda,期望它们分别输出 0、1 和 2。结果它们全都输出 3(结果的第 7 行)。实际上,[for] 循环 只有一个变量 [i],三个 Lambda 共享它。当这些 Lambda 被执行时,循环早已结束,[i] 等于 3;
- 第 42–43 行:修正方法。变量 [copy] 在循环体内声明:每次迭代都会创建一个 新变量,每个 Lambda 捕获的是它自己的变量;
- 第 51–53 行:使用 [foreach] 时不会出现这个问题。在 C# 4 之前,名为 [foreach] 的循环中的变量与名为 [for] 的循环中的变量一样是唯一的,这段代码会输出 2 2 2。C# 5 改变了这条规则(这是该语言历史上为数不多的不向后兼容的更改之一):变量 [j] 现在在每次迭代时都会重新初始化。[for] 循环则没有被修改;
- 第 46 行:[List<T>] 的方法 [ForEach] 需要一个 [Action<T>] 并对每个元素执行它。这里,每个元素本身就是一个 [Action] 委托,由该 Lambda 来执行。
[for] 循环陷阱主要出现在延迟处理中:注册为事件处理程序的 Lambda,或在另一个线程中启动的 Lambda(第 8 章),会在创建它们的循环结束之后才执行。
7.4. 委托还是接口?
委托和接口这两个概念看起来相当相似,人们可能会想知道两者究竟有什么区别。我们来看示例 [delegates-06.cs],它与 [delegates-02.cs]类似:
| // 委托类型的参数
// 执行 Add 委托
Console.WriteLine(Execute(Add, 2, 3));
// 执行 Subtract 委托
Console.WriteLine(Execute(Subtract, 2, 3));
// 执行多播委托
Operation op = Add;
op += Subtract;
Console.WriteLine(Execute(op, 2, 3));
// 执行 lambda:不需要具名方法
Console.WriteLine(Execute((n1, n2) => n1 * n2, 2, 3));
// 执行委托
static int Execute(Operation op, int n1, int n2)
{
return op(n1, n2);
}
// 两个具有 Operation 委托签名的方法
static int Add(int n1, int n2)
{
Console.WriteLine($"Add({n1},{n2})");
return n1 + n2;
}
static int Subtract(int n1, int n2)
{
Console.WriteLine($"Subtract({n1},{n2})");
return n1 - n2;
}
// 委托类型
delegate int Operation(int n1, int n2);
|
结果:
| > dotnet run delegates-06.cs
Add(2,3)
5
Subtract(2,3)
-1
Add(2,3)
Subtract(2,3)
-1
6
|
第 15 行,[Execute] 方法期望得到一个第 34 行定义的委托类型 [Operation] 的对象引用。这使得可以向 [Execute] 方法传入不同的方法(第 4、6、10 和 12 行)。最后一行甚至传给它一个 Lambda:不必再编写乘法方法。这种多态性也可以通过接口实现,如 [delegates-07.cs] 所示:
| // 接口类型的参数
// 执行 Add 操作
Console.WriteLine(Execute(new Add(), 2, 3));
// 执行 Subtract 操作
Console.WriteLine(Execute(new Subtract(), 2, 3));
// 执行 IOperation 接口的唯一方法
static int Execute(IOperation op, int n1, int n2)
{
return op.Operation(n1, n2);
}
// IOperation 接口
public interface IOperation
{
int Operation(int n1, int n2);
}
// Add 类
public class Add : IOperation
{
public int Operation(int n1, int n2)
{
Console.WriteLine($"Add({n1},{n2})");
return n1 + n2;
}
}
// Subtract 类
public class Subtract : IOperation
{
public int Operation(int n1, int n2)
{
Console.WriteLine($"Subtract({n1},{n2})");
return n1 - n2;
}
}
|
结果:
| > dotnet run delegates-07.cs
Add(2,3)
5
Subtract(2,3)
-1
|
说明:
- 第 15–17 行:[IOperation] 接口定义了一个 [Operation] 方法;
- 第 21–26 行和第 31–36 行:类 [Add] 和 [Subtract] 实现了接口 [IOperation];
- 第 9–11 行:方法 [Execute],其第一个参数的类型由接口 [IOperation] 定义。它依次接收类 [Add] 的一个实例作为第一个参数,然后是类 [Subtract] 的一个实例。
这清楚地展示了上一个示例中委托类型参数的多态特性。同时,这两个示例也凸显了这两个概念之间的差异。委托类型和接口类型是可以互换的:
- 如果接口只有一个方法。实际上,委托类型是对单个方法的封装,而接口可以定义多个方法;
- 如果不使用委托的多播特性。接口不存在这种多播概念。
如果这两个条件都满足,就可以为方法 [Execute] 在下面两种签名之间进行选择:
| int Execute(IOperation op, int n1, int n2)
int Execute(Operation op, int n1, int n2)
|
使用委托的第二种签名用起来更灵活。在第一种签名中,第一个参数必须实现 [IOperation] 接口:这就需要创建一个类来定义要传给 [Execute] 的方法。在第二种方式中,任何签名正确的现有方法都可以使用,Lambda 表达式甚至允许你在调用处直接定义该方法,无需任何额外代码。这种灵活性解释了为什么现代库(LINQ、异步编程、ASP.NET Core)大量使用委托。
一旦要传递的行为涉及多个相互关联的方法,或需要自己的状态和标识,接口就重新占据优势。第 6 章中 [dao] 层的 [ITaxDao] 接口就是这种情况:虽然它只有一个成员,但其实现带有状态(读取的税率档次、文件名),由依赖注入容器创建,并在应用程序中代表一个命名清晰的角色。[Func<TaxBracket[]>] 委托在技术上也足够了,但描述性会差得多。
7.5. 事件处理
7.5.1. .NET 事件模型
委托用于定义事件。类 [C1] 可以按如下方式定义事件 [Evt1]:
| delegate void Evt(T1 param1, T2 param2, ...);
|
- 当类 [c1] 的实例 [C1] 想要发出事件信号时,它会执行其委托 [Evt1],并向其传递类型 [Evt] 所定义的参数。随后,注册在委托 [Evt1] 中的所有方法都会以这些参数执行。可以说它们收到了事件 [Evt1] 的通知;
- 如果使用对象 [c1] 的对象 [c2] 想要收到对象 [c1] 的事件 [Evt1] 的通知,它就把自己的一个方法 [c2.M] 注册到委托 [c1.Evt1] 中。此后,每当对象 [c1] 上发生事件 [Evt1] 时,它的方法 [c2.M] 就会被执行。当它不再希望收到通知时,也可以取消订阅;
- 由于委托 [c1.Evt1] 可以注册多个方法,不同的 [ci] 对象可以向 [c1.Evt1] 注册以获得事件通知。
在这个场景中,我们有:
- 一个发出(也称为“发布”或“触发”)事件的类;
- 接收该事件通知的类。它们被称为订阅了该事件;
- 一个委托类型,用于定义接收事件通知的方法的签名。这些方法称为事件处理程序。
这就是观察者(Observer)设计模式:发出者并不知道其订阅者;它只是通知它们。
.NET 框架为事件委托定义了标准签名:
| public delegate void MyEventHandler(object? sender, EventArgs e);
|
- [sender]:触发事件的对象;
- [e]:类型为 [EventArgs] 或其派生类型的对象,提供有关事件的信息;
- 按照惯例,委托类型的名称以 [EventHandler] 结尾。
它还定义了在类中声明类型为 [MyEventHandler] 的事件的标准方式:
| public class C1
{
public event MyEventHandler? Evt1;
...
}
|
字段 [Evt1] 属于该委托类型。关键字 [event] 限制了可以对其执行的操作:
- 在类 [C1] 之外,只允许 [+=] 和 [-=] 操作。这可以防止其他对象覆盖或删除已订阅的方法(例如误将 [+=] 写成 [=])。你只能订阅([+=])或取消订阅([-=]);
- 只有类 [C1] 才能执行该委托,即触发事件:[Evt1?.Invoke(this, e)]。
如果你试图在类外部写 [c1.Evt1 = null;] 或 [c1.Evt1(null, EventArgs.Empty);],编译器会给出如下响应:[error CS0070: The event 'C1.Evt1' can only appear on the left hand side of += or -= (except when used from within the type 'C1')]。
我们不为每个事件都定义一个委托类型,而是使用预定义的泛型委托:
| public delegate void EventHandler<TEventArgs>(object? sender, TEventArgs e);
|
类型 [TEventArgs] 是第二个参数的类型,即描述事件的对象。使用这个泛型委托,在类 [X] 中声明事件 [C] 时遵循下面推荐的模式:
- 定义一个派生自 [XEventArgs] 的类型 [EventArgs] ,用于封装有关事件 [X] 的信息;
- 在类 [EventHandler<XEventArgs>] 中定义一个类型为 [C] 的事件;
- 在类 [C] 中定义一个受保护的虚方法 [protected virtual void OnX(XEventArgs e)] ,用于向订阅者发布事件 [X]。它是虚方法,以便派生类可以修改事件的发布方式。
在 2008 年,类型 [TEventArgs] 必须派生自 [EventArgs] (约束 [where TEventArgs : EventArgs])。这个约束在 .NET Framework 4.5 中被移除:任何类型都可以,包括 [record]。不过按照惯例,我们仍然派生自 [EventArgs]。请注意,[record] 不能派生自 [EventArgs]:[record] 只能继承另一个 [record](错误:[CS8864: Records may only inherit from object or another record])。因此我们将使用普通类。
7.5.2. 示例:温度过高
考虑下面的示例:
- 类 [Publisher] 封装了一个温度。当该温度超过某个阈值时,必须触发一个事件。我们将该事件称为 [TemperatureTooHigh]。有关该事件的信息被封装在类型 [TemperatureTooHighEventArgs] 中;
- 名为 [Subscriber] 的类订阅上述事件。当它收到事件通知时,会在控制台上显示一条消息。与 2008 年的版本不同,订阅者在收到指定数量的警报后会自动取消订阅;
- 一个控制台程序创建一个发布者和两个订阅者。它通过键盘输入温度并将其存储到发布者中。只要有温度过高,发布者就会发布 [TemperatureTooHigh] 事件。
2008 年的课程把这些类分布在项目的四个文件中。我们把它们合并到单文件应用程序 [delegates-08.cs] 中,分三部分展示。首先是事件信息类和类 [Publisher]:
| // 事件所携带的信息
public class TemperatureTooHighEventArgs(decimal temperature) : EventArgs
{
// 事件发生时的温度
public decimal Temperature { get; } = temperature;
// 事件发生的时间
public DateTime Time { get; } = DateTime.Now;
}
// 引发事件的类
public class Publisher(string name)
{
// 触发事件的阈值
public const decimal Threshold = 19;
// 发布者的名称
public string Name { get; } = name;
// 被引发的事件
public event EventHandler<TemperatureTooHighEventArgs>? TemperatureTooHigh;
// 观测到的温度
public decimal Temperature
{
get;
set
{
field = value;
if (value > Threshold)
{
// 向订阅者引发事件
OnTemperatureTooHigh(new TemperatureTooHighEventArgs(value));
}
}
}
// 引发事件
protected virtual void OnTemperatureTooHigh(TemperatureTooHighEventArgs e)
{
// 如果有订阅者,则向其发送事件
TemperatureTooHigh?.Invoke(this, e);
}
}
|
说明:
- 第 38–43 行:[TemperatureTooHighEventArgs] 类按惯例派生自 [EventArgs]。它使用主构造函数(C# 12,参见第 4 章):参数 [temperature] 初始化只读属性 [Temperature],它表示触发事件的温度。我们增加了事件时间 [Time]。事件信息是只读的:订阅者不能修改它,以免影响后续的订阅者;
- 第 50 行:温度阈值,超过它就会发布事件 [TemperatureTooHigh];
- 第 52 行:发送者有一个用于标识的名称;
- 第 54 行:事件 [TemperatureTooHigh],类型为 [EventHandler<TemperatureTooHighEventArgs>]。该类型可为 null([?]):只要没有人订阅,委托就被设为 [null];
- 第 57–66 行:属性 [Temperature]。其访问器 [set] 在记录的温度超过阈值时引发事件。它使用 C# 14 关键字 [field] (参见第 4 章),该关键字引用自动属性的隐藏字段:不再需要像 2008 年那样声明私有字段 [temperature] ;
- 第 66 行:发布工作由 [OnTemperatureTooHigh] 方法负责,向其传递一个 [TemperatureTooHighEventArgs] 对象,其中包含超过阈值的温度;
- 第 72–75 行:事件以发送者自身([this])作为第一个参数、以方法收到的对象作为第二个参数来发布。运算符 [?.] 是必不可少的:如果没有订阅者,[TemperatureTooHigh] 就等同于 [null]。2008 年的代码使用 [TemperatureTooHigh(this, evt)],在没有订阅者时会触发 [NullReferenceException]。写法 [TemperatureTooHigh?.Invoke(this, e)] 在多线程程序(第 8 章)中也更安全:委托只被读取一次,然后检查并执行;另一个线程中同时发生的取消订阅不会导致它在检查与调用之间变为 [null]。
下面是 [Subscriber] 类:
| // 订阅事件的类
public class Subscriber(string name, int nbAlertsMax)
{
// 订阅者的名称
public string Name { get; } = name;
// 收到的警报数量
private int nbAlerts;
// 订阅某个发布者的事件
public void Subscribe(Publisher publisher)
{
publisher.TemperatureTooHigh += EvtTemperatureTooHigh;
}
// 取消订阅
public void Unsubscribe(Publisher publisher)
{
publisher.TemperatureTooHigh -= EvtTemperatureTooHigh;
}
// TemperatureTooHigh 事件的处理程序
private void EvtTemperatureTooHigh(object? source, TemperatureTooHighEventArgs e)
{
if (source is not Publisher publisher)
{
return;
}
Console.WriteLine($"Subscriber [{Name}]: the source [{publisher.Name}] reported a temperature too high: [{e.Temperature}]");
// 超过 nbAlertsMax 次警报后,订阅者取消订阅
nbAlerts++;
if (nbAlerts == nbAlertsMax)
{
Unsubscribe(publisher);
Console.WriteLine($"Subscriber [{Name}]: unsubscribed after {nbAlerts} alert(s)");
}
}
}
|
说明:
- 第 80 行:每个订阅者由一个名称([Name])标识,并接收其可接受的最大警报数([nbAlertsMax]);
- 第 88–90 行:订阅发布者的事件。订阅者的方法 [EvtTemperatureTooHigh] 被记录到事件中:这是一次方法组转换。在 2008 年,订阅由主程序负责;这里则由订阅者自己负责,它必须知道取消订阅时要移除哪个方法;
- 第 94–96 行:取消订阅使用 [-=] 移除同一个方法。对委托而言,[s0] 的方法 [EvtTemperatureTooHigh] 与 [s1] 的方法是两个不同的方法,因为它们的目标([Target])不同:[-=] 只会移除相关订阅者的那一个;
- 第 100 行:事件处理程序。它具有委托 [EventHandler<TemperatureTooHighEventArgs>] 所规定的签名:一个 [object?] 和一个 [TemperatureTooHighEventArgs]。它是私有的:只有订阅者才能将其注册到发布者;
- 第 102 行:参数 [source] 的类型为 [object?]。模式过滤会验证它确实是一个 [Publisher] ,并将其存储在变量 [publisher] 中。2008 年的代码使用类型转换 [((Publisher)source).Name];
- 第 106 行:处理程序显示订阅者的名称、报告事件的发送者的名称,以及触发事件的温度;
- 第 108–111 行:在收到 [nbAlertsMax] 次警报之后,订阅者取消对发布者的订阅。订阅者是在事件 正在发布时于自己的处理程序中这样做的。这是安全的:我们已经看到委托是不可变的。[-=] 创建一个新的委托并将其存入事件字段,而当前的发布仍继续遍历旧的列表。
最后是主程序:
| // 事件处理:一个发布者和多个订阅者
// 创建事件发布者
var e1 = new Publisher("e");
// 创建两个订阅者,订阅 e1 的 TemperatureTooHigh 事件
Subscriber[] subscribers = [new("s0", 3), new("s1", 1)];
foreach (Subscriber subscriber in subscribers)
{
subscriber.Subscribe(e1);
}
// 第三个订阅者:一个 lambda
e1.TemperatureTooHigh += (source, e) => Console.WriteLine($"Log: {e.Temperature} °C at {e.Time:HH:mm:ss}");
// 从键盘读取温度
while (true)
{
Console.Write("Temperature (nothing to stop): ");
string input = Console.ReadLine()?.Trim() ?? "";
// 输入结束?
if (input == "")
{
break;
}
// 输入的是十进制数吗?
if (decimal.TryParse(input, out decimal temperature))
{
// 温度正确 - 把它存入发布者
e1.Temperature = temperature;
}
else
{
// 报告错误
Console.WriteLine("Incorrect temperature");
}
}
|
结果:
| > dotnet run delegates-08.cs
Temperature (nothing to stop): 17
Temperature (nothing to stop): 21
Subscriber [s0]: the source [e] reported a temperature too high: [21]
Subscriber [s1]: the source [e] reported a temperature too high: [21]
Subscriber [s1]: unsubscribed after 1 alert(s)
Log: 21 °C at 11:20:25
Temperature (nothing to stop): abc
Incorrect temperature
Temperature (nothing to stop): 22.5
Subscriber [s0]: the source [e] reported a temperature too high: [22.5]
Log: 22.5 °C at 11:20:27
Temperature (nothing to stop): 25
Subscriber [s0]: the source [e] reported a temperature too high: [25]
Subscriber [s0]: unsubscribed after 3 alert(s)
Log: 25 °C at 11:20:28
Temperature (nothing to stop): 30
Log: 30 °C at 11:20:28
Temperature (nothing to stop):
|
说明:
- 第 4 行:创建发送者;
- 第 6–9 行:创建两个订阅者,[s0] (最多 3 次警报)和 [s1] (1 次警报),它们订阅了发送者的事件 [TemperatureTooHigh]。集合表达式 [new("s0", 3), new("s1", 1)] 使用了无类型的 [new] 运算符(C# 9),因为类型由数组的类型推断得出;
- 第 12 行:第三个订阅者是一个 Lambda,充当日志。[source] 和 [e] 的类型由事件类型推断得出。Lambda 不容易取消订阅:必须把它存储在变量中,才能用 [-=] 移除,因为两个写法相同的 Lambda 是两个不同的委托。因此,Lambda 只适用于与发出者生命周期一样长的订阅;
- 第 15–33 行:通过键盘输入温度的循环。如果标准输入已关闭,[Console.ReadLine()] 返回 [null];[?.Trim() ?? ""] 将这种情况视为空输入;
- 第 28 行:如果输入的温度有效,就将其发送给发出者 [e1],如果温度高于 19 °C,它就会触发 [TemperatureTooHigh] 事件。
结果显示:
- 第 2 行:17 °C 没有超过阈值:没有事件;
- 第 3–7 行:21 °C 触发了事件。三个订阅者按订阅顺序收到通知。只接受一次警报的 [s1] 立即取消订阅,但这并不妨碍在它之后订阅的日志收到通知;
- 第 10–12 行:[s1] 不再收到通知;
- 第 13–16 行:[s0] 收到第三次警报,随后也取消订阅;
- 第 17 行:只剩下日志。
7.6. 委托与 LINQ
在第 5 章中,我们通过向 LINQ 的方法([Where]、[Select]、[OrderBy]……)传递 Lambda 来使用它们。现在我们知道这些参数是什么了:[Where] 方法在 [System.Linq.Enumerable] 类中的声明如下:
| public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
|
它的参数 [predicate] 是一个委托 [Func<TSource, bool>]:任何接受一个元素并返回布尔值的方法或 Lambda 都可以。为了彻底理解 LINQ 的工作原理,我们自己来编写一个过滤方法。这就是程序 [delegates-09.cs]:
| // 委托与 LINQ
int[] numbers = [3, 8, 1, 6, 5, 4, 9, 2];
// 1 - Where 和 Select 需要 Func<int, bool> 和 Func<int, TResult> 委托
Func<int, bool> isEven = n => n % 2 == 0;
var evenSquares = numbers.Where(isEven).Select(n => n * n);
Console.WriteLine($"LINQ: {string.Join(" ", evenSquares)}");
// 2 - 我们自己的过滤方法,先用 lambda 调用,再用方法组调用
Console.WriteLine($"Filter(n > 4): {string.Join(" ", Tools.Filter(numbers, n => n > 4))}");
Console.WriteLine($"Filter(IsOdd): {string.Join(" ", Tools.Filter(numbers, IsOdd))}");
// 3 - 执行是延迟的:谓词只在迭代时才被调用
IEnumerable<int> large = Tools.Filter(numbers, n =>
{
Console.Write($"[test {n}] ");
return n > 7;
});
Console.WriteLine("the query is defined, nothing has been executed yet");
foreach (int n in large)
{
Console.Write($"-> {n} ");
}
Console.WriteLine();
// 4 - 借助扩展成员,我们的方法可以像 LINQ 的方法一样链式调用
string[] cities = ["Angers", "Paris", "Lyon", "Nantes", "Aix"];
var result = cities.Filter(v => v.Length <= 5).Transform(v => v.ToUpper());
Console.WriteLine($"extension: {string.Join(" ", result)}");
static bool IsOdd(int n) => n % 2 != 0;
public static class Tools
{
// 用谓词过滤序列:相当于 Where
public static IEnumerable<T> Filter<T>(IEnumerable<T> source, Func<T, bool> predicate)
{
foreach (T element in source)
{
if (predicate(element))
{
// 元素返回给调用者;迭代将从这里继续
yield return element;
}
}
}
}
public static class Extensions
{
// IEnumerable<T> 的扩展成员(C# 14)
extension<T>(IEnumerable<T> source)
{
// Filter 作为扩展方法:复用 Tools.Filter
public IEnumerable<T> Filter(Func<T, bool> predicate) => Tools.Filter(source, predicate);
// 转换每个元素:相当于 Select
public IEnumerable<TResult> Transform<TResult>(Func<T, TResult> transformation)
{
foreach (T element in source)
{
yield return transformation(element);
}
}
}
}
|
结果:
| > dotnet run delegates-09.cs
LINQ: 64 36 16 4
Filter(n > 4): 8 6 5 9
Filter(IsOdd): 3 1 5 9
the query is defined, nothing has been executed yet
[test 3] [test 8] -> 8 [test 1] [test 6] [test 5] [test 4] [test 9] -> 9 [test 2]
extension: PARIS LYON AIX
|
说明:
- 第 6–7 行:[Where] 的 Lambda 先存储在类型为 [Func<int, bool>] 的变量中,以便揭示其类型。[Select] 则接收一个转换每个元素的委托 [Func<int, int>] :由此得到偶数的平方;
- 第 37–44 行:我们的方法 [Filter]。它是泛型的:使用类型为 [T] 的任意元素序列,通过类型为 [Func<T, bool>] 的谓词对其进行过滤。它遍历序列,并对每个元素调用该谓词(第 41 行);
- 第 44 行:[yield return] 语句将 [Filter] 变成了一个 迭代器:该方法并不构造列表,而是根据遍历结果的程序的请求,逐个返回所选元素。每次 [yield return] 之后,[Filter] 的执行都会被挂起;当请求下一个元素时,它会从同一位置继续;
- 第 11 行:用 Lambda 调用 [Filter]。类型 [T] 由数组推断为 [int]。第 12 行传给它的是一个方法组;
- 第 15–18 行:一个会打印其所测试的每个元素的冗长谓词。结果(第 5–6 行)表明,创建查询并不会执行任何操作:第 20 行的消息在第一次测试之前就显示了。只有在 [foreach] 循环期间,[Filter] 才会执行,并且测试与循环的打印语句交替进行。这就是 延迟执行,与 LINQ 查询的相同;
- 第 53–63 行:一个扩展成员块(C# 14,在第 4 章中介绍)为 [IEnumerable<T>] 类型添加了两个方法:[Filter],它复用 [Tools.Filter];以及 [Transform],相当于 [Select]。[Transform] 有两个泛型参数:[T] 是序列元素的类型,[TResult] 是转换所产生元素的类型;
- 第 29 行:得益于扩展方法,我们的方法就像序列自带的方法一样被调用,并且可以像 LINQ 的方法一样链式调用:我们保留 5 个字母或更少的城市名,然后将其大写。
整个 LINQ 库都建立在这种模型之上:[IEnumerable<T>] 的扩展方法接受委托并返回新的序列,这些序列由迭代器按需计算。
7.7. 表达式树
Lambda 表达式可以转换为委托,就像我们在本章中一直所做的那样。它也可以转换为 表达式树:编译器不是把 Lambda 编译为可执行代码,而是生成在运行时构造描述该 Lambda 的数据结构的指令。为此,只需使用命名空间 [System.Linq.Expressions] 中的类型 [Expression<TDelegate>] 来代替委托类型。程序 [delegates-10.cs] 对二者进行了比较:
| // 表达式树
using System.Linq.Expressions;
// 同一个 lambda,可以编译为委托,也可以作为数据保留
Func<int, bool> function = n => n > 5 && n % 2 == 0;
Expression<Func<int, bool>> expression = n => n > 5 && n % 2 == 0;
// 委托可以执行,但其代码不可读
Console.WriteLine($"delegate: {function}");
// 表达式树可以被遍历并显示
Console.WriteLine($"expression: {expression}");
Console.WriteLine($"parameter: {expression.Parameters[0].Name}, returned type: {expression.ReturnType.Name}");
Console.WriteLine("tree:");
Display(expression.Body, 1);
// 表达式树可以编译为委托然后执行
Func<int, bool> compiled = expression.Compile();
Console.WriteLine($"compiled(8)={compiled(8)}, compiled(7)={compiled(7)}");
// 递归显示树节点及其子节点
static void Display(Expression node, int level)
{
string margin = new(' ', 2 * level);
switch (node)
{
case BinaryExpression binary:
// 带两个操作数的运算:&&、>、==、%……
Console.WriteLine($"{margin}{binary.NodeType}");
Display(binary.Left, level + 1);
Display(binary.Right, level + 1);
break;
case ParameterExpression parameter:
Console.WriteLine($"{margin}Parameter {parameter.Name}");
break;
case ConstantExpression constant:
Console.WriteLine($"{margin}Constant {constant.Value}");
break;
default:
Console.WriteLine($"{margin}{node.NodeType} {node}");
break;
}
}
|
结果:
| > dotnet run delegates-10.cs
delegate: System.Func`2[System.Int32,System.Boolean]
expression: n => ((n > 5) AndAlso ((n % 2) == 0))
parameter: n, returned type: Boolean
tree:
AndAlso
GreaterThan
Parameter n
Constant 5
Equal
Modulo
Parameter n
Constant 2
Constant 0
compiled(8)=True, compiled(7)=False
|
说明:
- 第 2 行:命名空间 [System.Linq.Expressions] 不属于隐式 [using];
- 第 5–6 行:同一个 Lambda 先被赋给委托 [Func<int, bool>] ,然后被赋给表达式树 [Expression<Func<int, bool>>];
- 第 9 行:委托只能显示其类型;其代码已被编译,无法阅读;
- 第 11 行:而表达式树则可以显示。结果(第 3 行)重现了该 Lambda:[AndAlso] 是运算符 [&&] 的名称;
- 第 12 行:我们可以查询该树:它的参数、结果的类型,以及它的主体([Body]);
- 第 21–39 行:一个显示该树的递归方法。每个节点都是派生自 [Expression] 类的对象:[BinaryExpression] 用于双操作数运算([&&]、[>]、[==]、[%]),[ParameterExpression] 用于参数,[ConstantExpression] 用于常量。[switch] 配合基于类型的模式过滤来处理每种情况。结果(第 6–14 行)显示了表达式 [n > 5 && n % 2 == 0] 的结构;
- 第 17 行:表达式树可以在运行时编译为委托,然后执行。
这有什么用?委托只能在程序内部执行。而表达式树可以被解析并 翻译成另一种语言。Entity Framework Core 就是这么做的,我们将在第 11 章中探讨。当针对数据库表编写 LINQ 查询时,例如 [context.Brackets.Where(t => t.Limit > 20000)],所使用的 [Where] 方法并不是 [IEnumerable<T>] 的方法,而是 [IQueryable<T>] 的方法,其参数是 [Expression<Func<T, bool>>]。EF Core 会像我们的 [Display] 方法一样遍历这棵树,并将其翻译成由数据库服务器执行的 SQL [WHERE limits > 20000] 子句。因此,同一个以相同方式编写的 Lambda,会根据其所接收参数的类型,变成 .NET 代码或 SQL 代码。
7.8. 结论
本章的要点:
- 委托是引用一个或多个具有给定签名的方法的对象。预定义类型 [Func<>]、[Action<>] 和 [Predicate<T>] 通常使你无需定义自己的委托类型;
- Lambda 表达式允许你在创建委托的地方直接编写方法。它们会捕获其周围的变量(要小心 [for] 循环);
- 委托可以取代只有一个方法的接口,并提供更大的灵活性;
- 事件是受关键字 [event] 保护的委托:使用 [+=] 订阅,使用 [-=] 取消订阅,并且只有声明它的类才能使用 [Evt?.Invoke(this, e)] 触发它;
- LINQ 建立在接受委托的方法之上,而 EF Core 建立在表达式树之上。
在后续章节中还会再次讨论委托:任务([Task.Run])会在另一个线程中执行委托(第 8 章和第 9 章),ASP.NET Core Web 服务则将 Lambda 与 HTTP 地址关联起来(第 13 章)。