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新特性詳解系列專題，如有興趣，請關注本人公眾號，將定期優先在公眾號發布相關文章，

標籤：C#

上一篇：面試官：String長度有限制嗎？是多少？還好我看過

下一篇：Redis分布式快取系列（四）- Redis中的Set型別