C# 9.0 正式版新特性-有解無憂

11月10日，C# 9.0已經正式發布，一些新的特性也隨之而來，這個版本主要焦點放在了資料的簡潔性和不可變性表達上，

1. init關鍵字

1.1 僅初始化屬性 — init關鍵字

物件初始化方式對于創建物件來說是一種非常靈活和可讀的方式，特別對一口氣創建含有嵌套結構的樹型物件來說更有用，一個簡單的初始化例子如下：

var person = new Person { FirstName = "Mads", LastName = "Torgersen" };

原來要進行物件初始化，我們不得不寫一些含有set訪問器的屬性，并且在建構式的初次呼叫中，通過給屬性賦值來實作，

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

這種方式最大的局限就是，對于初始化來說，屬性必須是可變的，也就是說，set訪問器對于初始化來說是必須的，而其他情況下又不需要set，因此這個setter就不合適了，為了解決這個問題，僅僅只用來初始化的init訪問器出現了.，例如：

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

init訪問器是一個只在物件初始化時用來賦值的set訪問器的變體，并且除過初始化進行賦值外，后續其他的賦值操作是不允許的，上面定義的Person物件，在下面代碼中第一行初始化可以，第二行再次賦值就不被允許了，

var person = new Person { FirstName = "Mads", LastName = "Nielsen" }; // OK
person.LastName = "Torgersen"; // ERROR!

因此，一旦初始化完成之后，僅初始化屬性就保護著物件免于改變

1.2 init屬性訪問器和只讀欄位

因為init訪問器只能在初始化時被呼叫，所以在init屬性訪問器中可以改變封閉類的只讀欄位，

public class Person
{
    private readonly string firstName = "<unknown>";
    private readonly string lastName = "<unknown>";
    
    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 記錄 / Records

傳統面向物件的編程的核心思想是一個物件有著唯一標識，封裝著隨時可變的狀態，C#也是一直這樣設計和作業的，但是一些時候，你就非常需要剛好對立的方式，原來那種默認的方式往往會成為阻力，使得事情變得費時費力，如果你發現你需要整個物件都是不可變的，且行為像一個值，那么你應當考慮將其宣告為一個record型別，

public record Person
{
    public string? FirstName { get; init; }
    public string? LastName { get; init; }
}

一個record仍然是一個類，但是關鍵字record賦予這個類額外的幾個像值的行為，通常說，records由他們的內容來界定，不是他們的標識，從這一點上講，records更接近于結構，但是他們依然是參考型別，

2.1 with運算式

當使用不可變的資料時，一個常見的模式是從現存的值創建新值來呈現一個新狀態，例如，如果Person打算改變他的姓氏（last name），我們就需要通過拷貝原來資料，并賦予一個不同的last name值來呈現一個新Person，這種技術被稱為非破壞性改變，作為描繪隨時間變化的person，record呈現了一個特定時間的person的狀態，為了幫助進行這種型別的編程，records就提出了一個新的運算式——with運算式：

var person = new Person { FirstName = "Mads", LastName = "Nielsen" };
var otherPerson = person with { LastName = "Torgersen" };

with運算式使用初始化語法來說明新物件在哪里與原來物件不同，with運算式實際上是拷貝原來物件的整個狀態值到新物件，然后根據物件初始化器來改變指定值，這意味著屬性必須有init或者set訪問器，才能用with運算式進行更改，

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

protected Person(Person original) { /* 拷貝所有欄位 */ } // generated

with運算式就會引起拷貝建構式被呼叫，然后應用物件初始化器來有限更改屬性相應值，如果你不喜歡默認的產生的拷貝建構式，你可以自定以，with運算式也會進行呼叫，

2.2 基于值的相等

所有物件都從object型別繼承了 Equals(object)，這是靜態方法 Object.Equals(object, object) 用來比較兩個非空引數的基礎，

結構重寫了這個方法，通過遞回呼叫每個結構欄位的Equals方法，從而有了“基于值的相等”，Recrods也是這樣，這意味著只要他們的值保持一致，兩個record物件可以不是同一個物件就會相等，例如我們將修改的Last name又修改回去了：

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

現在我們會得到 ReferenceEquals(person, originalPerson) = false (他們不是同一物件)，但是 Equals(person, originalPerson) = true (他們有同樣的值).，與基于值的Equals一起的，還伴有基于值的GetHashCode()的重寫，另外，records實作了IEquatable<T>并多載了==和 !=這兩個運算子，以便于基于值的行為在所有的不同的相等機制方面顯得一致，

基于值的相等和可變性不總是契合的很好，一個問題是改變值可能引起GetHashCode的結果隨時變化，如果這個物件被存放在哈希表中，就會出問題，我們沒有不允許使用可變的record，但是我們不鼓勵那樣做，除非你已經想到了后果，

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

2.3 繼承 / Inheritance

記錄（record)可以從其他記錄（record)繼承：

public record Student : Person
{
    public int ID;
}

with運算式和值相等性與記錄的繼承結合的很好，因為他們考慮到了整個運行時物件，不只是靜態的已知型別，比如，我創建一個Student物件，將其存在Person變數里，

Person student = new Student { FirstName = "Mads", LastName = "Nielsen", ID = 129 };

with運算式仍然拷貝整個物件并保持著運行時的型別：

var otherStudent = student with { LastName = "Torgersen" };
WriteLine(otherStudent is Student); // true

同樣地，值相等性確保兩個物件有著同樣的運行時型別，然后比較他們的所有狀態：

Person similarStudent = new Student { FirstName = "Mads", LastName = "Nielsen", ID = 130 };
WriteLine(student != similarStudent); //true, 由于ID值不同

2.4 位置記錄 / Positional records

有時，有更多的位置定位方式對一個記錄是很有用的，在那里，記錄的內容是通過建構式的引數傳入，并且通過位置解構函式提取出來，你完全可能會在記錄中定義你自己的構造和解構函式（注意不是解構式），如下所示：

public record Person 
{ 
    public string FirstName { get; init; } 
    public string LastName { get; init; }
    public Person(string firstName, string lastName) 
      => (FirstName, LastName) = (firstName, lastName);
    public void Deconstruct(out string firstName, out string lastName) 
      => (firstName, lastName) = (FirstName, LastName);
}

也可以用更精簡的語法表達上面同樣的內容，

public record Person(string FirstName, string LastName);

該方式宣告了公開的、僅僅初始化的自動屬性、建構式和解構函式，和2.1種第一行代碼帶有大括號的宣告方式不同，現在你就可以寫如下代碼：

var person = new Person("Mads", "Torgersen"); // 位置建構式 / positional construction
var (f, l) = person;                        // 位置解構函式 / deconstruction

當然，如果你不喜歡產生的自動屬性，你可以你自己自定義的同名屬性代替，產生的建構式和解構函式將會只使用你自定義的那個，在這種情況下，該引數處于你用于初始化的作用域內，例如，你想讓FirstName是個保護屬性：

public record Person(string FirstName, string LastName)
{
    protected string FirstName { get; init; } = FirstName; 
}

一個位置記錄可以像下面這樣呼叫父類建構式，

public record Student(string FirstName, string LastName, int ID) : Person(FirstName, LastName);

3 頂層程式（Top-Level Programs)

通常，我們寫一個簡單的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像魔法一樣也是可用的，

using static System.Console;
using System.Threading.Tasks;

WriteLine(args[0]);
await Task.Delay(1000);
return 0;

本地函式作為陳述句的另一種形式，也是允許在頂層程式代碼中使用的，在頂層代碼段外部的任何地方呼叫他們都會產生錯誤，

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

（1）簡單型別模式

當前，進行型別匹配的時候，一個型別模式需要宣告一個識別符號——即使這識別符號是一個棄元_，像上面代碼中的DeliveryTruck _ ，但是在C#9.0中，你可以只寫型別，如下所示：

DeliveryTruck => 10.00m,

（2）關系模式

C#9.0 提出了關系運算子<,<=等對應的模式，所以你現在可以將上面模式中的DeliveryTruck部分寫成一個嵌套的switch運算式：

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,
},

中間的分支使用了and 來組合兩個關系模式來形成了一個表達區間的模式，

not模式的常見的使用是將它用在null常量模式上，如not null，例如我們要根據是否為空來把一個未知分支的處理進行拆分：

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

在包含了is運算式的if條件陳述句中，用于取代笨拙的雙括號，使用not也會很方便：

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

你可以這樣寫：

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

實際上，在is not運算式里，允許你給Customer指定名稱，以便后續使用，

if (e is not Customer c) { throw ... } // 如果這個分支拋出例外或者回傳...
var n = c.FirstName; // ... 這里，c肯定已經被賦值了，不會為空

5 型別推導new運算式

型別推導是從一個運算式所在的位置根據背景關系獲得它的型別時使用的一個術語，例如null和lambda運算式總是涉及到型別推導的，

在C#中，new運算式總是要求一個具體指定的型別（除了隱式型別陣列運算式），現在，如果運算式被指派給一個明確的型別時，你可以忽略new關鍵字后面的型別，

Point p = new (3, 5);

當有大量重復，這個特別有用，例如下面陣列初始化：

Point[] ps = { new (1, 2), new (5, 2), new (5, -3), new (1, -3) };

6 回傳值型別支持協變

有時候，在子類的一個重寫方法中回傳一個更具體的、且不同于父類方法的回傳型別更為有用，C# 9.0對這種情況提供了支持，如下列子中，子類Tiger的在重寫父類Animal的GetFood方法時，回傳值使用了Meat而不是Food，就更為形象具體，

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

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

標籤：C#

上一篇：C#高級之泛型

下一篇：求助：使用了cefsharp包的winform程式 clickonce發布后報錯:部署和應用程式沒有匹配的安全區域