C# 9.0 正式版所有新特性概述（最新完善版）

      C#9.0在11月10日已經正式發布。在這里我將C#9.0的一共16個新特性進行了匯總。新特性雖多，但本次這個版本主要落腳點還是放在了數據的簡潔性和不可變性表達上。

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() => ...;
}

 7. 本地大小的整型——nint和nuint

為了互操作和實現底層庫的需要，C# 9.0 引入了兩個新的上下文相關的關鍵字——有符號和無符號的兩個整型類型，即nint和nuint。這兩種類型的大小是32還是64的取決於所用平台。在被編譯之后，這兩個關鍵字會被轉換為System.IntPtr 和System.UIntPtr。

nint常量值介於范圍 [ int.MinValue, int.MaxValue ]，nuint的常量值介於范圍[ uint.MinValue, uint.MaxValue ]，但是他們沒有像int和uint那樣MaxValue和MinValue這兩個靜態屬性。同時，他們支持所有的一元{ +, -, ~ } 和二元運算符 { +, -, *, /, %, ==, !=, <, <=, >, >=, &, |, ^, <<, >> }. 

nint x = 3;
_ = nint.Equals(x, 3);

 

8. 靜態匿名方法

允許在Lambda表達式和匿名方法使用static關鍵字，用來防止訪問所處范圍的對象實例的狀態或者本地變量。 

Action<int> nc = static delegate (int x) {Console.WriteLine("Anonymous Method: {0}", x);
Action<int> la = static (int a) => a++;

 

9. 模塊初始化器

為了使在庫加載的時候，能以最小的開銷做一些期望的一次性的初始化工作，並且可以使源代碼生成器運行一些全局的初始化邏輯。C# 9.0引入了模塊初始化器。模塊初始化器被設計為一個Attribute:

using System; namespace System.Runtime.CompilerServices { [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] public sealed class ModuleInitializerAttribute : Attribute { } }

在你的代碼里，你可將這個ModuleInitializerAttribute用在符合下面要求的方法上就可以了。

1）方法必須使靜態的、無參的、返回值為void的函數。

2) 該方法不能是泛型或者包含在泛型類型里

3）該方法必須是可從其包含模塊里訪問的。也就是說，方法的有效訪問符必須是internal或者public，不能是本地方法。

using System.Runtime.CompilerServices; class MyClass​ { [ModuleInitializer] internal static void Initializer​() { // ...
 } }

 

10 本地函數支持Attribute

本地函數現在允許添加Attribute，並且參數和類型參數都是允許的。extern關鍵字也可以用於本地方法。這里，因為一個用的extern關鍵字，一個用的是ConditionalAttribute，所有都是static靜態方法。 

private static void PrintEnds(Func<bool> condition, string str, string separator ="+") { if (condition()) { Console.Write(str); } else { Console.Write(@$"{str} {separator} "); } ​ Log(); Print(); ​ [DllImport("log")] extern static void Log(); ​ [Conditional("DEBUG")] static void Print() { Console.WriteLine("print is running"); } }

 

11 擴展的分部方法

為了使partial方法變成為更為通用的C#方法聲明形式，C#9.0移除了partial方法簽名的所有限制。分部方法將方法划分聲明和定義兩部分,例如：

partial class MyClass { // MyClass.Print的聲明
    partial void Print(string message); } ​ partial class MyClass { // MyClass.Print的定義或實現
    partial void Print(string message) => Console.WriteLine(message); }

分部方法的一個行為是當定義/實現缺少時，編譯器會刪除方法聲明以及對該方法的調用。這類似於調用一個含有[Conditional]的方法，當條件為false時的情況。因為存在刪除這種情況，防止外部調用或引用失效引起的各種問題，所以存在以下幾個限制：

1. 返回值必須是void類型

2. 不能有out參數

3. 不能有任何訪問修飾符，隱式為private

C# 9.0 就是移除了這些限制，從而可以用out，可以是非void返回類型，也可顯式添加任何訪問級別的修飾符，也可以用extern等等所有的C#語言的表達形式。但是這樣修改的結果就是要求一個聲明必須有一個定義或實現。這樣，語言就不必考慮刪除調用產生的影響。看下面列子：

partial class MyClass { // 正確，因為沒有定義或者實現要求
    partial void Method1(); ​ // 正確，因為M2已經有了一個定義和實現了
    private partial void Method2(); ​ // 錯誤，含有顯式訪問修飾符的分部方法聲明必須有一個實現
    private partial void Method3(); } ​ partial class MyClass { private partial void Method2() { } }

此外，顯式訪問修飾符例子如下：

partial class MyClass2 { // 正確
    internal partial bool TryParse(string s, out int i); } ​ partial class MyClass2 { internal partial bool TryParse(string s, out int i) { } }

C#9.0現在對partial方法的限制如下：

• 帶有顯式訪問修飾符的partial聲明必須有一個定義/實現。

• partial的聲明和定義的簽名在方法和參數修飾上必須匹配，唯一不同的是參數名和attribute列表了。

 12 Lambda棄元參數

允許棄元被用作lambda和匿名表達式的的參數，從而沒有使用的參數可以不必被命名。例如：

Func<int,int,nint> f= (_, _) => 0; Func<int, int, nint> f2 = (int _,int _) => 0; Func<int, int, nint> f3 = delegate (int _, int _) { return 0; };

 13 類型推導的條件表達式

 

 對於一個條件表達式 c ? e1 : e2，當存在下面情況的時候，我們定義了一個新的隱式條件表達式轉換，它允許從條件表達式到任一類型T有一個隱式的轉換。 

• 對於e1和e2如果沒有共同的類型。

• 或者有共同的類型存在，但是e1或者e2的表達式沒有到共同類型的隱式轉換。

 對來自於表達式轉換為這個類型T的情況來說，有一個來自於從e1到T的轉換，也有一個從e2到T的轉換。如果條件表達式在e1和e2之間既沒有共同類型，也沒有相關適合的條件表達式轉換，那么就會出現錯誤。

  

14 方法指針

 

在今天的C#中，當前的中間語言IL的指令集沒能有效地被訪問，如：ldftn（將指向實現特定方法的本機代碼的非托管指針（native int 類型）推送到計算堆棧上）和calli（通過調用約定描述的參數調用在計算堆棧上指示的方法（作為指向入口點的指針））。方法指針就是提供了有效的方式來訪問IL指令集接口，以便開發人員能編寫高性能代碼。

 C#允許你用delegate*來聲明函數指針。

 unsafeclass Example {

void Example(Action<int> a, delegate*<int, void> f) {
        a(42);
        f(42);
    }
}

 

 15 禁止發出localsinit標記

 

編譯器對所有帶有局部變量的方法發出localsinit標記，告訴他們對所有局部變量進行初始化，以防止代碼運行時產生不可預知的錯誤。允許通過SkipLocalsInitAttribute 屬性來禁止發出localsinit標記。對於自動初始化局部變量，特別是使用stackalloc的數據的時候，他們所花的成本是非常明顯的，對於性能要求特別高的程序，該特性是有重要意義的。

 

[SkipLocalsInit]
unsafe static void Print()
{
    Span<int> members = stackalloc int[100];
    for (var i = 0; i < length; i++)
    {
        numbers[i] = i;
     }
}

SkipLocalsInitAttribute可以用於方法，屬性，模塊，類，結構、接口和構造函數。應用於在容器（類、模塊，包含嵌入函數的函數等）上時，其里面所有的方法都會受到影響。對於抽象函數和和沒有傳播到的覆蓋/實現的方法，時無效的。

  

16 擴展GetEnumerator支持foreach循環

 允許foreach循環能識別以擴展方法定義的GetEnumberator()方法，該方法的定義必須滿足foreach模式的其他要求：

1. GetEnumerator()的返回值類型必須是類，結構或者接口，並且返回值類型有成員符合要求的方法MoveNext()和屬性Current。
2. GetEnumerator()不能有類型參數。

  上述16個新特性為C#9.0這次的所有新添加功能。限於篇幅原因，針對每個新特性詳細解釋，不在此羅列，后面，我將做一個C#9.0新特性詳解系列專題。

如有興趣，請關注本人微信公眾號“碼客風雲”，將定期優先在公眾號發布相關文章。