Build 2020上公布的C# 9.0 新特性-有解無憂

在微軟的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() => ...;
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/33192.html

標籤：C#

上一篇：C# 資料操作系列 - 12 NHibernate的增刪改查

下一篇：C# .NET Socket SocketHelper 高性能 5000客戶端異步接收資料