〔译〕C# 7 的新特性

原文：What's new in C# 7
2016-12-21

译者注：原文于 2016 年 12 月发表，当时 Visual Studio 2017 还是 15 Preview 5，不过直到 VS2017 它们仍然没什么变化。

---

C# 7 中添加了不少语言特性：

• out 变量

  • 你可以在向方法传入参数的时候定义 out 变量

• 元组(Tuples)

  • 可用于创建轻量、无名称、包含多个公共字段的类型。编译器和 IDE 工具知道这些类型的语义。

• 模式匹配

  • 基于任意类型和它们的值创建逻辑分支。

• 定义为 ref 的局部变量和返回值

  • 方法参数和局部变量可以在其它位置引用

• 局部函数

  • 可以在函数中嵌入函数定义，嵌入函数受外部函数作用域和可见性限制。

• 更多成员可使用表达式语法

  • 可使用表达式编写的成员列表已经得到扩充。

• throw 表达式

  • 你可以在代码结构中抛出异常，而在之前因为它是语句，做不到这一点。

• 异步返回类型泛型化

  • 使用 async 定义的方法可以返回除 Task 和 Task 之外的类型了。

• 改善数字字符量语法

  • 使用新的符号提高数字常量的可读性。

  本文下面对每个特性都进行了详述。你可以了解到每个特性背后的原因，也可以学习到相关的语法。还有一些使用这些特性的场景示例。所有这些都会让你成为更有高效的开发者。

out 变量

现有的语法已经支持 out 参数，但它在这个版本中得到了改进。

之前，你需要在两个语句中申明和使用输出(out)变量：

int numericResult;
if (int.TryParse(input, out numericResult))
    WriteLine(numericResult);
else
    WriteLine("Could not parse input");

而现在可以在调用方法的时候直接在参数列表中定义 out 变量，避免单独的申明语句：

if (int.TryParse(input, out int result))
    WriteLine(result);
else
    WriteLine("Could not parse input");

你可以像上面那样明确的申明 out 变量的类型，不过语言本身支持对局部变量使用隐式类型(自动推断)：

if (int.TryParse(input, out var answer))
    WriteLine(answer);
else
    WriteLine("Could not parse input");

• 这个代码非常易读

  • 在使用输出变量的时候申明它，不需要另加一行代码

• 不需要赋予初始值

  • 在方法中使用 out 变量的时候才申明它，就不会出现还没有赋值就使用的情况。

这个特性最常用的地方是在使用 try 模式的时候。在这个模式中，方法会返回 bool 值来标标识它是成功还是失败，如果成功，其处理的结果则是通过 out 变量提供的。

元组(Tuples)

C# 提供了丰富语法来支持类和结构，而类和结构主要用于解释你的设计思想。然而有时候，丰富的语法也需要一些额外的工作所带来的小优势。你可能经常会在写到某个方法时发现需要一个简单但又包含多个数据元素的结构。为了支持这类情况，C# 添加了元组。元组是轻量级的数据结构，包含多个字段来表示数据成员。这些字段不经过验证。另外，你也不能在元组中定义自己的方法。

注：在 C# 7 之前，元组已经通过 API 实现，但这个实现有很多限制。最重要的是，元组的成员被命名为 Item1、Item2 等(译者注：语义不明)。语言(译者注：指 C# 7 支持为元组的字段定义语义化化的名称。

可以通过对元组的每个成员赋值来定义元组：

var letters = ("a", "b");

这个赋值语句通过元组语法创建了一个元组，其成员是 Item1 和 Item2。可以修改这个赋值语句，使元组具有语义化的成员：

(string Alpha, string Beta) namedLetters = ("a", "b");

注：新的元组特性需要 System.ValueTuple 类型。在 Visual Studio 2017 和之前的预览版本中，你需要添加 NuGet 包 System.ValueTuple。

namedLatters 元组包含 Alpha 和 Beta 两个字段。在元组赋值过语句中，你也可以在右侧指定字段的名称：

var alphabetStart = (Alpha: "a", Beta: "b");

C# 语言允许你在赋值语句的左侧和右侧同时指定字段名称：

(string First, string Second) firstLetters = (Alpha: "a", Beta: "b");

上面这一行会产生一个警告，CS8123，告诉你赋值语句右侧指定的 Alpha 和 Beta 这两个名称会被忽略，因为它们与左侧指定的 First 和 Second 名称产生了冲突。

上面的例子展示了基本的元组语法。元组通常用于 private 和 internal 方法的返回类型。元组为这些方法提供了简单的语法来返回多个数值：不再需要为返回数据定义 class 或 struct 类型的工作，很省事。

创建元组更有效率。这是用来定义多值数据的一个简单而轻量的语法。下面作为示例的方法找到并返回一组整数的最小值和最大值：

private static (int Max, int Min) Range(IEnumerable numbers)
{
    int min = int.MaxValue;
    int max = int.MinValue;
    foreach(var n in numbers)
    {
        min = (n < min) ? n : min;
        max = (n > max) ? n : max;
    }
    return (max, min);
}

这里使用元组带来了如下优势：

• 省事。不需要为返回类型定义 class 或 struct
• 不需要创建新的类型
• 增强的语言不再需要调用 Create(T1) 方法

方法申明中为返回元组数据的字段提供了名称。调用这个方法的时候，返回的元组会有 Max 和 Min 两个字段：

var range = Range(numbers);

有时候你可能想将方法返回的元组数据拆解开。没问题，你可以为元组的每个字段单独申明变量。这称为对元组进行解构(deconstructing):

(int max, int min) = Range(numbers);

你也可以为 .NET 中任意类类型提供类似的解构功能，方法是为类提供一个 Deconstruct 成员方法(译者注：称为解构方法，注意与析构方法区分)。Deconstruct 方法提供一组 out 参数，对应于你想解构出来的每一个属性。下面的 Point 类提供了一个解构方法用于提取 X 和 Y 坐标：

public class Point
{
    public Point(double x, double y)
    {
        this.X = x;
        this.Y = y;
    }

    public double X { get; }
    public double Y { get; }

    public void Deconstruct(out double x, out double y)
    {
        x = this.X;
        y = this.Y;
    }
}

现在可以通过将 Point 对象赋值到元组来提取各个字段：

var p = new Point(3.14, 2.71);
(double X, double Y) = p;

定义 Deconstruct 方法的时候并没有绑定名称。你可以在赋值语句中提取变量时对其命名：

(double horizontalDistance, double verticalDistance) = p;

更多相关内容，请参阅元组主题

模式匹配

模式匹配功能让你可以在方法中根据对象类型之外的属性进行处理。你可能已经很熟基于对象类型的方法处理。在面向对象编程中，虚方法和重载方法语法用于实现基于对象类型的方法处理。基类和派生类会提供不同的实现。模式匹配语法扩展了这个概念，让你很容易根据类型和数据元素实现类似的处理模式，而这与继承无关。

模式匹配支持 is 表达式和 switch 表达式。它通过对对象及其属性的检查来确定对象是否满足所要求的模式。使用 when 关键字来为模式指定附加规则。

is 表达式

is 模式表达式扩展了大家熟悉的 is 运算符，用不仅限于类型的方式来查询对象。

让我们从一个简单的问题开始。我们会扩展这个问题来演示模式匹配是如何简便处理问题的。首先，我们来计算一个掷骰结果的数值之和。

public static int DiceSum(IEnumerable values)
{
    return values.Sum();
}

很快你发现需要统计的结果掷骰列表中，有些时候并不是只掷了一个骰子。输入的每一项都有可能是多个结果，而不仅仅是一个数：

public static int DiceSum2(IEnumerable