C#9.0：Records

概述

在C#9.0下，record是一個關鍵字，微軟官方目前暫時將它翻譯為記錄類型。

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

所以record類型的實際是一個引用類型 ，但是他具有值類型的行為。

先來回顧一下引用類型，C# 中有兩種類型：引用類型和值類型。 引用類型的變量存儲對其數據（對象）的引用，而值類型的變量直接包含其數據。 對於引用類型，兩種變量可引用同一對象；因此，對一個變量執行的操作會影響另一個變量所引用的對象。 對於值類型，每個變量都具有其自己的數據副本，對一個變量執行的操作不會影響另一個變量。

那我們舉個例子，創建一個實體，包含用戶名、昵稱、年齡

/// <summary>
/// 用戶信息對象
/// </summary>
public class UserInfo
{
     public string UserName { get; init; }
     public string UserNickName { get; init; }
     public int UserAge { get; set; }
} 

因為UserInfo是個類對象，是引用類型，所以我們進行如下輸出：

 UserInfo u = new UserInfo()
            {
                UserName = "翁智華",
                UserNickName = "Brand",
                UserAge = 10
            };
            var uclone = u;
            uclone.UserAge = 11;
            Console.WriteLine(ReferenceEquals(u,uclone));
            Console.WriteLine("u:{0},uclone:{1}", JsonConvert.SerializeObject(u), JsonConvert.SerializeObject(uclone));

輸出結果如下，可以看出，這兩個對象是相等的，當ucolone的值發生改變的時候，他所引用的對象也發送了變化：

  這個是我們所熟悉的知識，那么怎樣理解 Record 實際是一個引用類型 ，但具有值類型的行為的特征。這時候就要認識一下它的 with 表達式。

with表達式

當我們使用引用類型時，最常用的一種方式是我們想用基於當前的對象，去修改他的值以便產生一個新的對象，這時候就不能直接賦值等於，否則會出現上述的改變引用對象情況。

如果我想修改年齡，就需要拷貝一份用戶信息表，並且基於這份拷貝的新對象來修改值。這樣的做法有個專業的名詞叫做 non-destructive mutation，即 非破壞性突變。

而記錄類型(record)不是代表 對象在一段時間內的 狀態，而是代表對象在給定時間點的狀態，並且使用with表達式來實現給定時間點的狀態的產生。

舉個例子，記住下面record的使用：

 /// <summary>
 /// 用戶信息對象
 /// </summary>
 public record UserInfoRecord
 {
        public string UserName { get; init; }
        public string UserNickName { get; init; }
        public int UserAge { get; init; }
 } 

在使用with表達式的時間點，ucolone 就是 u 對象所在這個時間點的產生的新狀態，這時候 u 對象和 uclone 對象並不相等，值也不一致。

 var u = new UserInfoRecord()
 {
         UserName = "翁智華",
         UserNickName = "Brand",
         UserAge = 10
  };
 var uclone = u with { UserAge=11 }; 

以上就是兩個不同時間點對象狀態的比較，跟我們上面理解的一致，如果實際場景需要，可以產生多個對應時間點的對象狀態。

所以record和with本質是使用現有對象，並將對象內的字段逐一的復制到新的對象的過程。來看看微軟官方的說明：

記錄(record)隱式定義了一個受保護的(protected)“復制構造函數”——一個接受現有記錄對象並逐字段將其復制到新記錄對象的構造函數：

protected Person(Person original) { /* copy all the fields */ } // generated

with 表達式會調用“復制構造函數”，然后在上面應用對象初始化器來相應地變更屬性。

如果您不喜歡生成的“復制構造函數”的默認行為，您可以定義自己的“復制構造函數”，它將被 with 表達式捕獲。 

基於值的相等

我們知道，C#的對象可以使用Object.Equals(object, object)來比較兩個非空參數，判斷是否相等。結構重寫了這個方法，通過遞歸調用每個結構字段的Equals方法，所以有 “基於值的相等”。

recrods也是這樣，所以着只要他們的值保持一致，兩個record對象可以不是同一個對象也會相等（這種相等是基於值的相等，並不是指他們是一個對象）。

基於上面定義的record，我們做如下修改： 

UserInfoRecord u1 = new UserInfoRecord()
{
      UserName = "翁智華",
      UserNickName = "Brand",
      UserAge = 10
};

UserInfoRecord u2 = new UserInfoRecord()
{
      UserName = "翁智華",
      UserNickName = "Brand",
      UserAge = 10
};
Console.WriteLine("ReferenceEquals:" + (ReferenceEquals(u1,u2)), Encoding.GetEncoding("GB2312"));
Console.WriteLine("Equals:" + (u1.Equals(u2)), Encoding.GetEncoding("GB2312")); 

通過上面的結果，我們可以得到 ReferenceEquals(person, originalPerson) = false (他們不是同一對象)，但是 Equals(person, originalPerson) = true (他們有同樣的值)。

與基於值的Equals一起的，還伴有基於值的GetHashCode()的重寫。同時，records實現了IEquatable<T>並重載了==和 !=這兩個操作符，以便於基於值的行為在所有的不同的相等機制方面顯得一致。 

繼承性：Inheritance 

基礎類（class）不能從記錄（record）中繼承，否則會提示錯誤，只有記錄（record)可以從其他記錄（record)繼承，如下，我們繼承上面的那個記錄：

  /// <summary>
  ///  繼承用戶信息record，並擴展Sex屬性
  /// </summary>
  public record UserInfoRecord2 : UserInfoRecord
  {
      public int Sex { get; init; }
  }

 

對應地，with表達式和基於值的對等性，也相應的結合在一起，下面是繼承后，對類型的判斷：

UserInfoRecord u1 = new UserInfoRecord2()
 {
          UserName = "翁智華",
          UserNickName = "Brand",
          UserAge = 10,
          Sex = 1
 };
var u2 = u1 with { UserAge=18  };
Console.WriteLine("IsUserInfoRecord2:" + (u2 is UserInfoRecord2)); 

 兩個對象在運行時保證了同樣的類型的基礎上，就可以用基於值的相等來進行比較了：

 UserInfoRecord u3 = new UserInfoRecord2()
 {
         UserName = "翁智華",
         UserNickName = "Brand",
         UserAge = 18,
         Sex = 1
  };
  Console.WriteLine("u2 equal u3:" + (u2.Equals(u3)));

 

因為u2之前UserAge改成18了，所以u2跟u3在這邊基於值相等，結果如下：

位置記錄：Positional Records

使用記錄(record)可以明確數據在整個實體中的位置，采用構造函數的參數的方式提供，並且可以通過位置解構提取出數據。

原來我們想要通過構造和解構進行賦值和獲取值需要這么寫：

/// <summary>
/// 用戶信息對象
/// </summary>
public record UInfoRecord
{
    public string UserName;
    public string NickName;
    public int Age;
    public UInfoRecord(string userName, string nickName,int age) => (UserName, NickName,Age) = (userName,nickName,age);
    public void Deconstruct(out string userName,out string nickName,out int age) => (userName, nickName, age) = (UserName, NickName, Age);
} 

通過構造來提供內容和通過解構來獲取內容：

var uinfo = new UInfoRecord("翁智華", "Brand",18); // 構造
String name ="", nick = "";
int age = 0;
uinfo.Deconstruct(out name,out nick,out age); // 解構
Console.WriteLine("解構獲取值，name:{0}，nick:{1}，age:{2}",name,nick,age); 

 現在可以通過更加精簡的方式完成上面的工作，稱為 參數名稱包裝模式（modulo casing of parameter names），

只要用包裝模式聲明記錄（記錄的位置是嚴格區分的），包含了三個自動屬性 ，就可以使用構造函數和解構函數來提供內容和獲取內容了，上面的內容可以改寫成如下：

/// <summary>
/// 用戶對象
/// </summary>
public record UInfoRecord(string UserName,string NickName,string Age); 

var uinfo = new UInfoRecord("翁智華", "Brand",18); // 位置構造函數 / positional construction
var (name,nick,age) = uinfo;                        // 位置解構函數 / deconstruction
Console.WriteLine("解構獲取值，name:{0}，nick:{1}，age:{2}",name,nick,age);

獲得的結果是一樣的。

如果你想修改默認提供的自動屬性，可以自定義的同名屬性代替，產生的構造函數和解構函數將會只使用你自定義的那個。如下，重新定義了Age自動屬性，並默默的把值+1：

/// <summary>
/// 用戶對象
/// </summary>
public record UInfoRecord(string UserName, string NickName, int Age)
{
     public int Age { get; init; } = Age+1;
}

  

總結

個人感覺record的出現使得對象的使用更加的便捷，一個是對象的復制和使用（with 表達式），不同時間點的數據狀態是不一樣的；一個是對象的比較（基於值的相等），避免我們進行逐個比較。