C# 9.0新特性詳解系列之五：記錄(record)和with表達式

1 背景與動機

傳統面向對象編程的核心思想是一個對象有着唯一標識，表現為對象引用，封裝着隨時可變的屬性狀態，如果你改變了一個屬性的狀態，這個對象還是原來那個對象，就是對象引用沒有因為狀態的改變而改變，也就是說該對象可以有很多種狀態。C#從最初開始也是一直這樣設計和工作的。但是一些時候，你可能非常需要一種恰好相反的方式，例如我需要一個對象只有一個狀態，那么原來那種默認方式往往會成為阻力，使得事情變得費時費力。

當一個類型的對象在創建時被指定狀態后，就不會再變化的對象，我們稱之為不可變類型。這種類型是線程安全的，不需要進行線程同步，非常適合並行計算的數據共享。它減少了更新對象會引起各種bug的風險，更為安全。System.DateTime和string就是不可變類型非常經典的代表。

原來，我們要用類來創建一個不可變類型，你首先要定義只讀字段和屬性，並且還要重寫涉及相等判斷的方法等。在C#9.0中，引入了record，專門用來以最簡的方式創建不可變類型的新方式。如果你需要一個行為像值類型的引用類型，你可以使用record；如果你需要整個對象都是不可變的，且行為像一個值，那么你也可考慮將其聲明為一個record類型。 那么什么是record類型？

2 Record介紹

record類型是一種用record關鍵字聲明的新的引用類型，與類不同的是，它是基於值相等而不是唯一的標識符——對象引用。他有着引用類型的支持大對象、繼承、多態等特性，也有着結構的基於值相等的特性。可以說有着class和struct兩者的優勢，在一些情況下可以用以替代class和struct。

提到不可變的類型，我們會想到readonly struct，那么為什么要選擇添加一個新的類型，而不是用readonly struct呢？這是因為記錄有着如下優點：

• 在構造不可變的數據結構時，它的語法簡單易用。

• record為引用類型，不用像值類型在傳遞時需要內存分配，並進行整體拷貝。

• 構造函數和結構函數為一體的、簡化的位置記錄

• 有力的相等性支持 —— 重寫了Equals(object), IEquatable , 和GetHashCode()這些基本方法。

2.1 record類型的定義與使用

2.1.1 常規方式

record類型可以定義為可變的，也可以是不可變的。現在，我們用record定義一個只有只讀屬性的Person類型如下。這種只有只讀屬性的類型，因為其在創建好之后，屬性就不能再被修改，我們通常把這種類型叫做不可變類型。

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

    public Person(string first, string last) => (FirstName, LastName) = (first, last);
}

上面這種聲明，在使用時，只能用帶參的構造函數進行初始化。要創建一個record對象跟類沒有什么區別：

Person person = new("Andy", "Kang");

如果要支持用對象初始化器進行初始化，則在屬性中使用init關鍵字。這種形式，如果不需要用帶參的構造函數進行初始化，可以不定義帶參的構造函數，上面的Person可以改為下面形式。

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

現在，創建Person對象時，用初始化器進行初始化如下：

Person person = new() { FirstName = "Andy", LastName = "Kang"};

如果需要是可變類型的record，我們定義如下。這種因為有set訪問器，所以它支持用對象初始化器進行初始化，如果你想用構造函數進行初始化，你可以添加自己的構造函數。

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

}

2.1.2 位置記錄 / Positional records

為了支持將record對象能解構成元組，我們給record添加解構函數Deconstruct。這種record就稱為位置記錄。下面代碼定義的Person，記錄的內容是通過構造函數的參數傳入，並且通過位置解構函數提取出來。你完全可以在記錄中定義你自己的構造和解構函數（注意不是析構函數）。如下所示：。

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

針對上面如此復雜的代碼，C#9.0提供了更精簡的語法表達上面同樣的內容。需要注意的是，這種記錄類型是不可變的。這也就是為什么有record默認是不可變的說法由來。

public record Person(string FirstName, string LastName);

該方式聲明了公開的、僅可初始化的自動屬性、構造函數和解構函數。現在創建對象，你就可以寫如下代碼：

var person = new Person("Mads", "Torgersen"); // 位置構造函數
var (firstName, lastName) = person;                        // 位置解構函數

當然，如果你不喜歡產生的自動屬性、構造函數和解構函數，你可以自定義同名成員代替。在調用構造函數和解構函數時，將會只使用你自定義的那個。在這種情況下，被自定義參數處於你用於初始化的作用域內，例如，你想讓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);

2.1.3 小結

record默認情況下是被設計用來進行描述不可變類型的，因此位置記錄這種短小簡明的聲明方式是推薦方式。

2.2 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" };

如果只是進行拷貝，不需要修改屬性，那么無須指定任何屬性修改，如下所示：

Person clone = person with { };

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

需要注意的是：

• with表達式左邊操作數必須為record類型。
• record的引用類型的成員在拷貝的時候，只是將所指實例的引用進行了拷貝。

2.3 record的面向對象的特性——繼承、多態等

記錄（record)和類一樣，在面向對象方面，支持繼承，多態等所有特性。除過前面提到的record專有的特性，其他語法寫法跟類也是一樣。同其他類型一樣，record的基類依然是object。
要注意的是：

• 記錄只能從記錄繼承，不能從類繼承，也不能被任何類繼承。

• record不能定義為static的，但是可以有static成員。

下面一個學生record，它繼承自Person：

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

public sealed record Student : Person
{
    public int ID { get; init; }
}

對於位置記錄，只要保持record特有的寫法即可：

public record Person(string FirstName, string LastName);

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

public sealed record Teacher(string FirstName, string LastName, string Title) : Person(FirstName, LastName)
{
    public override string ToString()
    {
        StringBuilder s = new();
        base.PrintMembers(s);
        return $"{s.ToString()} is a Teacher";
    }
}

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 record實現原理

從本質上來講，record仍然是一個類，但是關鍵字record賦予這個類額外的幾個像值的行為。也就是，當你定義了record時候，編譯器會自動生成以下方法，來實現基於值相等的特性（即只要兩個record的所有屬性都相等，且類型相同，那么這兩個record就相等）、對象的拷貝和成員及其值的輸出。

• 基於值相等性的比較方法，如Equals,==,!=,EqualityContract等。

• 重寫GetHashCode()

• 拷貝和克隆成員

• PrintMembers和ToString()方法

例如我先定義一個Person的記錄類型：

public record Person(string FirstName, string LastName);

編譯器生成的代碼和下面的代碼定義是等價的。但是要注意的是，跟編譯器實際生成的代碼相比，名字的命名是有所不同的。

public class Person : IEquatable<Person>
{
    private readonly string _FirstName;
    private readonly string _LastName;

    protected virtual Type EqualityContract
    {
        get
        {
            return typeof(Person);
        }
    }

    public string FirstName
    {
        get
        {
            return _FirstName;
        }
        init
        {
            _FirstName = value;
        }
    }
    public string LastName
    {
        get
        {
            return _LastName;
        }
        init
        {
            _LastName = value;
        }
    }
    public Person(string FirstName, string LastName)
    {
        _FirstName = FirstName;
        _LastName = LastName;
    }

    public override string ToString()
    { 
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.Append("Person");
        stringBuilder.Append(" { ");
        if (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(" ");
        }
        stringBuilder.Append("}");
        return stringBuilder.ToString();
    }

    protected virtual bool PrintMembers(StringBuilder builder)
    { 
        builder.Append("FirstName");
        builder.Append(" = ");
        builder.Append((object)FirstName);
        builder.Append(", ");
        builder.Append("LastName");
        builder.Append(" = ");
        builder.Append((object)LastName);
        return true;
    }

    public static bool operator !=(Person r1, Person r2)
    {
        return !(r1 == r2);
    }

    public static bool operator ==(Person r1, Person r2)
    {
        return (object)r1 == r2 || ((object)r1 != null && r1.Equals(r2));
    }

    public override int GetHashCode() 
    { 
        return (EqualityComparer<Type>.Default.GetHashCode(EqualityContract) * -1521134295 
                + EqualityComparer<string>.Default.GetHashCode(_FirstName)) * -1521134295 
                + EqualityComparer<string>.Default.GetHashCode(_LastName);
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as Person);
    }

    public virtual bool Equals(Person other)
    { 
        return (object)other != null 
                && EqualityContract == other.EqualityContract 
                && EqualityComparer<string>.Default.Equals(_FirstName, other._FirstName) 
                && EqualityComparer<string>.Default.Equals(_LastName, other._LastName);
    }

    public virtual Person Clone()
    { 
        return new Person(this);
    }

    protected Person(Person original)
    { 
        _FirstName = original._FirstName;
        _LastName = original._LastName;
    }
    public void Deconstruct(out string FirstName, out string LastName)
    { 
        FirstName = this.FirstName;
        LastName = this.LastName;
    }
}

這些由編譯器生成的一些成員，是允許編程人員自定義的，一旦編譯器發現有自定義的某個成員，它就不會再生成這個成員。

由此可見，record實際上就是編譯器特性，並且records由他們的內容來界定，不是他們的引用標識符。從這一點上講，records更接近於結構，但是他們依然是引用類型。

2.4.1 基於值的相等

所有對象都從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 並重載了==和 !=這兩個操作符，這些都是為了基於值的行為在所有的不同的相等機制方面保持一致。

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

如果你不喜歡默認Equals重寫的字段與字段比較行為，你可以進行重寫。你只需要認真理解基於值的相等時如何在records中工作原理，特別是涉及到繼承的時候。

除了熟悉的Equals，==和！=操作符之外，record還多了一個新的EqualityContract只讀屬性，該屬性返回類型是Type類型，返回值默認為該record的類型。該屬性用來在判斷兩個具有繼承關系不同類型的record相等時，該record所依據的類型。下面我們看一個有關EqualityContract的例子，定義一個學生record，他繼承自Person：

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

這個時候，我們分別創建一個Person和Student實例，都用來描述同樣的人：

Person p = new Person("Jerry", "Kang");
Person s = new Student("Jerry", "Kang", 1);
WriteLine(p == s); // False

這兩者比較的結果是False，這與我們實際需求不相符。那么我們可以重寫EqualityContract來實現兩種相等：

public record Student(string FirstName, string LastName, int Level) : Person(FirstName, LastName)
{
    protected override Type EqualityContract
    {
        get => typeof(Person);
    }
}

經過此改造之后，上面例子中的兩個實例就會相等。EqualityContract的修飾符是依據下面情況確定的：

• 如果基類是object, 屬性是virtual；
• 如果基類是另一個record類型，則該屬性是override；
• 如果基類類型是sealed，則該屬性也是sealed的。

2.4.2 拷貝克隆與with表達式

一個record在編譯的時候，會自動生成一個帶有保護訪問級別的“拷貝構造函數”，用來將現有record對象的字段值拷貝到新對象對應字段中：

protected Person(Person original) { /* 拷貝所有字段 */ } // 編譯器生成

with表達式就會引起拷貝構造函數被調用，然后應用對象初始化器來有限更改屬性相應值。如果你不喜歡默認的產生的拷貝構造函數，你可以自定義該構造函數，編譯器一旦發現有自定義的構造函數，就不會在自動生成，with表達式也會進行調用。

public record Person(string FirstName, string LastName)
{
    protected Person(Person original)
    {
        this.FirstName = original.FirstName;
        this.LastName = original.LastName;
    }
}

編譯器默認地還會生成with表達式會使用的一個Clone方法用於創建新的record對象，這個方法是不能在record類型里面自定義的。

2.4.3 PrintMembers和ToString()方法

如果你用Console.WriteLine來輸出record的實例，就會發現其輸出與用class定義的類型的默認的ToString完全不同。其輸出為各成員及其值組成的字符串：

Person {FirstName = Andy, LastName = Kang}

這是因為，基於值相等的類型，我們更加關注於具體的值的情況，因此在編譯record類型時會自動生成重寫了ToString的行為的代碼。針對record類型，編譯器也會自動生成一個保護級別的PrintMembers方法，該方法用於生成各成員及其值的字符串，即上面結果中的大括號內部的內容。ToString中，就調用了PrintMembers來生成其成員字符串部分，其他部分在ToString中補充。

我們也可以定義PrintMembers和重寫ToString方法來實現自己想要的功能，如下面實現ToString輸出為Json格式：

public record Person(string FirstName, string LastName)
{
    protected virtual bool PrintMembers(StringBuilder builder)
    {
        builder.Append("\"FirstName\"");
        builder.Append(" : ");
        builder.Append($"\"{ FirstName}\"");
        builder.Append(", ");
        builder.Append("\"LastName\"");
        builder.Append(" : ");
        builder.Append($"\"{ LastName}\"");
        return true;
    }

    public override string ToString()
    {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.Append("{");
        if (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(" ");
        }
        stringBuilder.Append("}");
        return stringBuilder.ToString();
    }
}

record因為都是繼承自Object，因此ToString都是采用override修飾符。而PrintMembers方法修飾符是依據下面情況決定的：

• 如果記錄不是sealed而是從object繼承的, 該方法是protected virtual；

• 如果記錄基類是另一個record類型，則該方法是protected override；

• 如果記錄類型是sealed，則該方法也是private的。

3 應用場景

3.1 Web Api

用於web api返回的數據，通常作為一種一次性的傳輸型數據，不需要是可變的，因此適合使用record。

3.2 並發和多線程計算

作為不可變數據類型record對於並行計算和多線程之間的數據共享非常適合，安全可靠。

3.3 數據日志

record本身的不可變性和ToString的數據內容的輸出，不需要人工編寫很多代碼，就適合進行日志處理。

3.4 其他

其他涉及到有大量基於值類型比較和復制的場景，也是record的常用的使用場景。

4 結束語

在生產應用中，有着眾多的使用場景，以便我們用record來替換寫一個類。未知的還在等我們進一步探索。

如對您有價值，請推薦，您的鼓勵是我繼續的動力，在此萬分感謝。關注本人公眾號“碼客風雲”，享第一時間閱讀最新文章。