Build 2020上公佈的C# 9.0 新特性

在微軟的Build 2020開發者大會中，微軟就正在成形的C#9.0的一些即將添加的主要特性進行了說明。 1.init屬性訪問器對象初始化方式對於創建對象來說是一種非常靈活和可讀的格式，特別是對樹狀嵌入型對象的創建。簡單的例如 new Person { FirstName = "Scott", L ...

在微軟的Build 2020開發者大會中，微軟就正在成形的C#9.0的一些即將添加的主要特性進行了說明。

1.init屬性訪問器

對象初始化方式對於創建對象來說是一種非常靈活和可讀的格式，特別是對樹狀嵌入型對象的創建。簡單的例如

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

原有的要進行對象初始化，我們必須要做就是寫一些屬性，並且在構造函數的初次調用中，通過給屬性的setter賦值來實現。

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

就這樣的方式而言，set訪問器對於初始化來說是必須的，但是如果你想要的是只讀屬性，這個set就是不合適的。除過初始化，其他情況不需要，而且很多情況下容易引起屬性值改變。為瞭解決這個矛盾，只用來初始化的init訪問器出現了。init訪問器是一個只在對象初始化時用來賦值的set訪問器的變體，並且後續的賦值操作是不允許的。例如：

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

2. init屬性訪問器和只讀欄位

因為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)));
    }
}

3. Records

如果你需要一個整個對象都是不可變的，且行為像一個值的類型，你可以考慮將其聲明為record。

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

關鍵字data用來將類標記為record。這樣類就具有了像值一樣的行為。records意味看起來更像值，也就是數據，而且很少像對象。不是說他們有可變的封裝的狀態，而是通過創建代表新狀態的records來呈現隨時間變化的狀態。records不是被他們的標識符界定，而是被他們的內容所界定的。

4. With表達式

當用不可變的數據類型時，一個公用的模式是從現存的值類創建新值來呈現一個新狀態。例如，如果Person改變了他的last name，我們就需要通過拷貝原來數據，並設置一個不同的last name來呈現一個新Person。這種技術被稱為非破壞性改變。作為呈現隨時間變化的person，record呈現了一個特定時間的person的狀態。為了幫助這種類型的編程處理，records就提出了一個新的表達式，這就是with表達式：

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

with表達式使用初始化語法來聲明與原來對象不同的新狀態對象。

一個record隱式定義了一個帶有保護訪問級別的“拷貝構造函數”，用來將現有record對象的欄位值拷貝到新對象對應欄位中：

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

with表達式就會引起拷貝構造函數進行調用，然後應用對象初始化器來有限更改屬性相應值。如果你不喜歡預設的產生的拷貝構造函數，你可以自定以，with表達式也會進行調用。

5. 基於值的相等

所有對象都從object類型繼承了 Equals(object)，這是靜態方法 Object.Equals(object, object) 用來比較兩個非空參數的基礎。

結構重寫這個方法，通過遞歸調用每個結構欄位的Equals方法，從而有了“基於值的相等”，Recrods也是這樣。這意味著那樣與他們無值保持一致，兩個record對象可以不用是同一個對象，而且相等。例如我們修改回了last name：

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

現在我們會有 ReferenceEquals(person, originalPerson) = false (他們不是同一對象)，但是 Equals(person, originalPerson) = true (他們有同樣的值).。

如果你不喜歡預設Equals重寫的欄位與欄位比較行為，你可以進行重寫。你只需要認真理解基於值的相等時如何在records中工作原理，特別是涉及到繼承的時候，後面我們會提到。

與基於值的Equals一起的，還伴有基於值的GetHashCode()的重寫。

6.data成員

不可變的Records的成員是帶有init的公共屬性，可以通過with表達式進行無破壞性修改的。為了優化這種共有情況，records改變了形如string FirstName的預設意思，即在結構和類中聲明的隱式私有欄位，在records中成了公有，僅初始化自動屬性。

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

上面這段聲明，就是跟下麵這段代碼意思相同：

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

這個使得record聲明看起來優美而清晰直觀。如果你真的需要一個私有欄位，你可以顯式添加private修飾符。

private string firstName;

7. Positional records

在record是可以指定構造函數和解構函數（註意不是析構函數）的。

public data class Person 
{ 
    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);

該方式聲明瞭公開的帶有初始化自動屬性、構造函數和解構函數，和第6條第一段代碼帶有大括弧的聲明方式是不同的。現在你就可以寫如下代碼：

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

當然，如果你不喜歡產生的自動屬性，你可以自定義你自己的同名屬性代替，產生的構造函數和解構函數將會只使用那個。

8.Records和變化

record基於值這種語義沒有很好應對可變狀態這種情況。想象給字典插入一個record對象。要查找到它，就得根據Equals和（一些時候）GetHashCode。但是如果record改變了狀態，它們也會跟著改變。這樣，我們就可能再找不到這個record。在哈希表實現中，這樣可能會損害數據結構，由於放置位置是基於它到達的哈希碼。

現實中，存在有一些record內部的可變狀態的有效的高級應用，如緩存。但是在重寫預設行為來忽略這種狀態所涉及的人工工作可能是相當多的。

9. with表達式和繼承

眾所周知，基於值相等和非破壞性變化值的方式在和繼承糾結在一起時，非常具有挑戰性。下來，我們添加一個繼承的record類Student來說明我們的例子：

public data class Person { string FirstName; string LastName; }
public data class Student : Person { int ID; }

下來，我們通過創建一個Student，但是把他存放到Person變數中，來說明with表達式的使用：

Person person = new Student { FirstName = "Scott", LastName = "Hunter", ID = GetNewId() };
otherPerson = person with { LastName = "Hanselman" };

在最後一行，編譯器不知道person實際存放的是一個Student，這樣，新person對象就不會得到正確的拷貝，即就不會像4中的第一段代碼拷貝那樣，得到同樣ID值。

C#為了使這個得以正確工作。Records有一個隱藏的virtual方法，用於執行整體對象的克隆。每個派生的record類型重寫了這個方法，以調用那個類型的拷貝構造函數，派少的record構造函數也受約束於父record的拷貝構造函數。with表達式簡單調用這個隱藏的“clone”方法，應用對象初始化器給結果。

10. 基於值相等和繼承

類似於with表達式的支持，基於值的相等性也必須是“virtual”，在這種意義上來說，Students需要比較所有student欄位，即使在比較時靜態已知類型是像Person這樣的基類，也容易通過重寫已經有的virtual Equals方法來實現。

然而，相等有著一個格外的挑戰，就是如果比較兩個不同類型的Person會怎麼樣？我們不能讓他們中一個決定應用哪一個相等性：相等應該是語義的，所以不管兩個對象中哪個先來，解構應是相同的。換句話說，他們必須在被應用的相等性達成一致。

這個問題的例子如下：

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

這兩個對象是不是彼此相等？person1可能這樣認為，由於person2有著person所有的成員，並且值相等，但是person2不敢苟同。我們需要確認他們兩個對於他們是不同對象達成一致意見。

再一次，C#自然為你考慮到了這個，實現的方式是records有一個虛擬保護的屬性，叫做EqualityContract。每個派生的record重寫它，以便比較相等，兩個對象必須有同樣的EqualityContract。

11.頂級程式

通常，我們洗一個簡單的C#程式，都要求有大量的樣例代碼：

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

這個對於初學者是無法抗拒，但是這使得代碼凌亂，大量堆積，並且增加了縮進層級。在C#9.0中，你可以選擇在頂級用如下代碼代替寫你的主程式：

using System;

Console.WriteLine("Hello World!");

當然，任何語句都是允許的。但是這個程式代碼必須出現在using後，在任何類型或者命名空間聲明的前面。並且你只能在一個文件裡面這樣做，像你如今只寫一個main方法一樣。

如果你想返回狀態，你可以那樣做，你想用await，也可以那樣做。並且，如果你想訪問命令行參數，args也是可用的。

本地方法是語句的另一個形式，也是允許在頂級程式代碼用的。在頂級代碼段外部的任何地方調用他們都會產生錯誤。

12. 增強的模式匹配

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

（1）簡單類型模式

當前，當類型匹配的時候，一個類型模式需要聲明一個標識符——即使這標識符是_，像上面代碼中的DeliveryTruck _ 。但是在C#9.0中，你可以只寫類型，如下所示：

DeliveryTruck => 10.00m,

（2）關係模式

C#9.0 推出了關係運算符相應的模式，例如<,<=等等。所以你現在可以用switch表達式將下上面模式中的DeliveryTruck部分寫成下麵樣子：

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

這的 > 5000 和 < 3000是關係模式。

（3）邏輯模式

最後，你可以用邏輯操作符and，or 和not將模式進行組合，來詳細說明，以避免表達式操作符引起的混淆。例如，上面嵌入的switch可以按照升序排序，如下：

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

中間的case使用了and 來組合兩個關係模式形成了一個表達區間的模式。

not模式的公同使用是它將會被用在null常量模式上，就像not null。例如我們要根據是否為空來分割一個未知的case處理代碼段：

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

not將在包含了is表達式的if條件語句使用也會很方便，並且會取代笨重的雙括弧：

if (!(e is Customer)) { ... }

你可以這樣寫：

if (e is not Customer) { ... }

13. 增強的類型推導

類型推導是當一個表達式從它所被使用的地方的上下文中獲得它的類型時，我們經常使用的一個專業術語。例如null和lambda表達式總是涉及到類型推導的。

在C#9.0中，先前沒有實現類型推導的一些表達式現在也可以用他們的上下文來進行類型推導了。

（1）類型推導的new表達式

在C#中，new表達式總是要求一個具體指定的類型（除了隱式類型數組表達式）。現在，如果表達式被指派給一個明確的類型時，你可以忽略new中類型。

Point p = new (3, 5);

（2）類型推導的??和?:

一些時候，條件表達式??和?:在分支中沒有明顯的共用類型。現有這種情況會失敗，但是在C#9.0中，如果各分支可以轉換為目標類型，這種情況時允許的。

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

14.支持協變的返回值

一些時候，在子類的一個重寫方法中返回一個更具體的、且不同於父類方法定義的返回類型更為有用，C# 9.0對這種情況提供了支持。

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