【译】Welcome to C# 9.0

　　C# 9.0正在形成，我想分享我们对添加到该语言下个版本的一些主要功能的看法。对于每个新版本的 C#，我们努力使常见的编码方案更加清晰和简单，C# 9.0 也不例外。这次的一个特别重点是支持数据形状的简洁和不可变表示。

　　让我们潜入吧！

1 仅可初始化的属性

　　对象初始化器是非常好用的。它们为类型实例化提供了一种非常灵活且可读的格式来创建对象，尤其是对于一次创建特别大的嵌套对象来说。下面是一个简单的例子：

new Person
{
    FirstName = "Scott",
    LastName = "Hunter"
}

　　对象初始化也使用户不必编写大量构造函数，要做的就是编写一些属性！

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

　　今天，一个很大的限制是，属性必须是可修改的，对象初始化器是这样工作的：首先调用对象的构造函数（默认为无参的构造函数），然后分配给属性设置器（property setter）。

　　仅可初始化属性修改了这一点！它们引入了一个 init 访问器，该访问器是set访问器的变体，只能在对象初始化期间调用：

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

　　使用此声明，除了初始化外，之后任何后续赋值给 FirstName 和 LastName 属性都是一个错误。

　　因为init访问器只能在初始化期间访问，因此他们允许修改封闭类型中的只读字段，就像在构造函数中那样：

public class Person
{
    private readonly string firstName;
    private readonly string lastName;
   
    public string FirstName
    {
        get => firstName;
        init => firstName = (value ?? throw new ArgumentNullException(nameof(FirstName)));
    }
    public string LastName
    {
        get => lastName;
        init => lastName = (value ?? throw new ArgumentNullException(nameof(LastName)));
    }
}

2 记录

　　如果要使单个属性不可变，则仅可初始化属性非常适合。如果希望整个对象不可变且像值类型一样，则应考虑将其声明为记录：

public data class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

　　类声明中的data关键字将其标记为记录。这赋予它几个类似价值类型的行为，我们将在下面深入探讨这些行为。一般来说，记录更被视为"值"（纯数据），而不是作为对象。您可以通过创建新记录表示新状态来表示随时间的变化。它们不是由标识定义，而是由其内容定义。

2.1 With表达式

　　使用不可变数据时，一种常见模式是从现有值创建新值以表示新状态。例如，如果我们更改LastName，我们会将其表示为一个新对象，该对象是旧对象的副本，但LastName不同。这种技术通常被称为非破坏性修改。记录这种特性表示的是Person在给定时间的状态。

　　为了适应这种编程风格，记录允许一种新的表达式——with：

var otherPerson = person with{LastName="Hanselman"};

　　with表达式使用对象初始化器语法来说明新对象与旧对象的不同内容。您可以指定多个属性。

　　记录隐式定义一个受保护的"复制构造函数"-一个构造函数，它获取现有记录对象，并逐个将其字段复制到新的对象：

protected Person(Person original){/* copy all the fields */}// generated

　　with 表达式会导致调用复制构造函数，然后在上面应用对象初始化器以相应地更改属性。

　　如果您不喜欢生成的复制构造函数的默认行为，则可以改为定义自己的行为，该行为将由with表达式选取。

2.2 基于值的相等性

　　所有对象都从Object继承 Equals(object)。结构将其重写为具有"基于价值的相等性"，通过递归地调用Equals来比较结构的每个字段。记录也执行相同的操作。这意味着，根据其"值"，两个记录对象可以彼此相等，而不必是同一对象。例如：

var originalPerson = otherPerson with { LastName = "Hunter" };

　　现在 ReferenceEquals(person, originalPerson) = false（这两个不是一个对象）但是Equals(person, originalPerson) = true （他们有相同的值）。

　　如果您不喜欢生成的 Equals 重写的默认逐字段比较行为，则可以改为编写自己的字段比较行为。你只需要小心，你了解基于值的相等在记录中是如何工作的，特别是当涉及继承时。

　　除了重写Equals 外，还有 GetHashCode()。

2.3 数据成员

　　记录绝大多数都是不可变的，只有只读初始化器可以通过with表达式进行非破坏性修改。为了针对这种常见情况进行优化，记录在声明时会更改string FirstName这类成员声明的行为。与其他类和结构声明中的隐式private字段不同，在记录中，这被视为public的、仅可初始化的自动属性的缩写！因此：

public data classPerson
{
    string FirstName;
    string LastName;
}

　　与

public data classPerson
{
    public string FirstName{get; init;}
    public string LastName{get; init;}
}

　　是相同的。

　　我们认为这有助于做出漂亮而清晰的记录声明。如果您真的需要私有字段，只需显式地添加private修饰符：

private string firstName;

2.4 基于位置的记录

　　有时，对记录采用更为位置化的方法是有用的，在这种方法中，记录的内容通过构造函数参数的位置给出，并且可以通过解构函数来提取。

　　可以在记录中指定自己的构造函数和解构函数：

public data classPerson
{
    string FirstName;
    string LastName;
    public Person(string firstName,string lastName)
      =>(FirstName,LastName)=(firstName, lastName);
    public void Deconstruct(out string firstName,out string lastName)
      =>(firstName, lastName)=(FirstName,LastName);
}

　　上面代码可以简写为：

public data class Person(string FirstName,string LastName);

　　这将声明public的仅初始化的自动属性以及构造函数和解构函数，以便您可以编写：

var person =new Person("Scott","Hunter");// positional construction
var(f, l)= person;                        // positional deconstruction

　　如果您不喜欢生成的自动属性，则可以改为定义自己的同名属性，生成的构造函数和解构函数将使用该属性。

2.5 记录的改变引发的问题

　　想象一下，将记录对象放入字典中。再次找到它取决于 Equal 和GetHashCode。如果记录改变其状态，它也会改变它等于什么！我们可能再也找不到了！在哈希表实现中，它甚至可能损坏数据结构，因为定位基于的是"到达哈希表时"的哈希值！

　　虽然可以通过重写一些内部方法来改变这种默认的行为，但其工作量也是相当巨大的。

2.6 with表达式与继承

public data class Person{string FirstName;string LastName;}
public data class Student:Person{int ID;}
Person person =new Student{FirstName="Scott",LastName="Hunter", ID =GetNewId()};
otherPerson = person with{LastName="Hanselman"};

　　在最后一行上使用with表达式时，编译器不知道person实际上包含了一个Student。而且，即使otherPerson实际上不是"Student"对象，它也不是一个正确的副本，该对象与复制的第一个对象具有相同的ID。

　　记录有一个隐藏的虚方法，它委托"克隆"整个对象。每个派生记录类型都重写此方法以调用该类型的复制构造函数，以及派生链上的复制构造函数直到基类记录的复制构造函数。with表达式只需调用隐藏的"克隆"方法，并将对象初始化器应用于结果。

2.7 值相等与继承

　　与with表达式的实现类似，基于值的相等性也必须是"虚拟"的，即Student需要比较所有字段，即使比较时能够得知类型是基类型Person。这是很容易通过重写已经虚拟的Equals方法实现的。

　　但是，相等还有一个挑战：如果比较两种不同的Person，该怎么办？我们不能让其中一个决定是否相等：相等应该是对称的，所以无论两个对象中哪个是第一个，结果都应该是相同的。换句话说，他们必须就适用的相等达成一致！

　　说明问题的示例：

Person person1 =new Person{FirstName="Scott",LastName="Hunter"};
Person person2 =new Student{FirstName="Scott",LastName="Hunter", ID =GetNewId()};

　　这两个对象彼此相等吗？person1可能会这样认为，因为person2有所有的Person的构造，但person2会认为与person1不同！我们需要确保他们都同意他们是不同的对象。

　　C# 会自动为您处理。它的实现方式是每个记录都有一个"EqualityContract"的虚拟受保护属性。每个派生记录都会重写它，为了比较相等，两个对象必须具有相同的EqualityContract。

3 简化顶级程序

　　之前我们这样写代码：

using System;
class Program
{
    static void Main()
    {
        Console.WriteLine("Hello World!");
    }
}

　　现在您可以选择在顶层编写主程序：

using System;
Console.WriteLine("Hello World!");

　　支持任何语句，但必须在using之后以及文件中的任何类型或命名空间声明之前，并且只能在一个文件中执行此操作，就像目前只能有一个Main方法一样。如果要返回状态代码，可以执行此操作。如果你想await，你可以这样做。如果要访问命令行参数，可以访问args参数。

　　局部函数是语句的一种形式，在顶级程序中也允许使用。从顶级语句部分以外的任何位置调用它们都是错误的。

4 改进模式匹配

　　在 C# 9.0 中添加了几种新类型的模式。例如：

public static decimal CalculateToll(object vehicle) =>
    vehicle switch
    {
       ...
        DeliveryTruck t when t.GrossWeightClass > 5000 => 10.00m + 5.00m,
        DeliveryTruck t when t.GrossWeightClass < 3000 => 10.00m - 2.00m,
        DeliveryTruck _ => 10.00m,
        _ => throw new ArgumentException("Not a known vehicle type", nameof(vehicle))
    };

4.1 简单类型模式

　　目前，类型模式需要在类型匹配时声明一个标识符，即使该标识符是一个_，比如 DeliveryTruck _。新语法不用了，可以简写为：

DeliveryTruck => 10.00m,

4.2 关系模式

　　C#9.0引入了对应于关系运算符<、<=等的模式。因此，新语法可以这样写：

DeliveryTruck t when t.GrossWeightClass switch
{
    > 5000 => 10.00m + 5.00m,
    < 3000 => 10.00m - 2.00m,
    ...
},

4.3 逻辑模式

　　最后，可以将模式与逻辑运算（and 、or、not）符组合起来，并将其拼写为单词，以避免与表达式中使用的运算符混淆。例如:

DeliveryTruck t when t.GrossWeightClass switch
{
    < 3000 => 10.00m - 2.00m,
    >= 3000 and <= 5000 => 10.00m,
    > 5000 => 10.00m + 5.00m,
},

　　not的常见用法是将其应用于判空。例如：

not null => throw new ArgumentException($"Not a known vehicle type: {vehicle}", nameof(vehicle)),
null => throw new ArgumentNullException(nameof(vehicle))

　　还有，if (!(e is Customer)) { ... }在新语法中，可以写为if (e is not Customer) { ... }

5 目标类型

　　"Target typing"是当表达式从使用位置的上下文中获取其类型时，我们使用的术语。C# 9.0支持新的类型推断。

5.1 new

　　新语法中，如果是明确的类型，则在使用new时，可以不声明类型了。比如：

Point p = new (3, 5);

5.2 ?? and ?:

　　目前，??与?:如果分支之间不是同一类型会报错。新语法下，如果两个分支都可以转换为目标类型则是允许的：

Person person = student ?? customer; // Shared base type
int? result = b ? 0 : null; // nullable value type

6 改进协变

　　有时，派生类中的方法返还比基类中的声明更具体的类型是很有用的。C# 9.0 允许：

abstract class Animal
{
    public abstract Food GetFood();
    ...
}
class Tiger : Animal
{
    public override Meat GetFood() => ...;
}

　　此外，还要很多新的改进，让我们拭目以待吧。

原文链接

https://devblogs.microsoft.com/dotnet/welcome-to-c-9-0/?utm_source=vs_developer_news&utm_medium=referral

posted @ 2020-06-01 01:50 MeteorSeed 阅读(825) 评论(1) 编辑收藏举报

刷新页面返回顶部

MeteorSeed

专注于.NET Core、架构设计、项目管理以及DevOps。