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 表达式），不同时间点的数据状态是不一样的；一个是对象的比较（基于值的相等），避免我们进行逐个比较。