概述

在C#9.0下，record是一个关键字，微软官方目前暂时将它翻译为记录类型。

传统面向对象的编程的核心思想是一个对象有着唯一标识，封装着随时可变的状态。C#也是一直这样设计和工作的。但是一些时候，你就非常需要刚好对立的方式。原来那种默认的方式往往会成为阻力，使得事情变得费时费力。如果你发现你需要整个对象都是不可变的，且行为像一个值，那么你应当考虑将其声明为一个record类型。

所以record类型的实际是一个引用类型 ，但是他具有值类型的行为。

先来回顾一下引用类型，C# 中有两种类型：引用类型和值类型。 引用类型的变量存储对其数据（对象）的引用，而值类型的变量直接包含其数据。 对于引用类型，两种变量可引用同一对象；因此，对一个变量执行的操作会影响另一个变量所引用的对象。 对于值类型，每个变量都具有其自己的数据副本，对一个变量执行的操作不会影响另一个变量。

那我们举个例子，创建一个实体，包含用户名、昵称、年龄

1 /// <summary>
2 /// 用户信息对象
3 /// </summary>
4 public class UserInfo
5 {
6      public string UserName { get; init; }
7      public string UserNickName { get; init; }
8      public int UserAge { get; set; }
9 } 

因为UserInfo是个类对象，是引用类型，所以我们进行如下输出：

 1  UserInfo u = new UserInfo()
 2             {
 3                 UserName = "翁智华",
 4                 UserNickName = "Brand",
 5                 UserAge = 10
 6             };
 7             var uclone = u;
 8             uclone.UserAge = 11;
 9             Console.WriteLine(ReferenceEquals(u,uclone));
10             Console.WriteLine("u:{0},uclone:{1}", JsonConvert.SerializeObject(u), JsonConvert.SerializeObject(uclone));

输出结果如下，可以看出，这两个对象是相等的，当ucolone的值发生改变的时候，他所引用的对象也发送了变化：

  这个是我们所熟悉的知识，那么怎样理解 Record 实际是一个引用类型 ，但具有值类型的行为的特征。这时候就要认识一下它的 with 表达式。

with表达式

当我们使用引用类型时，最常用的一种方式是我们想用基于当前的对象，去修改他的值以便产生一个新的对象，这时候就不能直接赋值等于，否则会出现上述的改变引用对象情况。

如果我想修改年龄，就需要拷贝一份用户信息表，并且基于这份拷贝的新对象来修改值。这样的做法有个专业的名词叫做 non-destructive mutation，即 非破坏性突变。

而记录类型(record)不是代表 对象在一段时间内的 状态，而是代表对象在给定时间点的状态，并且使用with表达式来实现给定时间点的状态的产生。

举个例子，记住下面record的使用：

1  /// <summary>
2  /// 用户信息对象
3  /// </summary>
4  public record UserInfoRecord
5  {
6         public string UserName { get; init; }
7         public string UserNickName { get; init; }
8         public int UserAge { get; init; }
9  } 

在使用with表达式的时间点，ucolone 就是 u 对象所在这个时间点的产生的新状态，这时候 u 对象和 uclone 对象并不相等，值也不一致。

1  var u = new UserInfoRecord()
2  {
3          UserName = "翁智华",
4          UserNickName = "Brand",
5          UserAge = 10
6   };
7  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，我们做如下修改： 

 1 UserInfoRecord u1 = new UserInfoRecord()
 2 {
 3       UserName = "翁智华",
 4       UserNickName = "Brand",
 5       UserAge = 10
 6 };
 7 
 8 UserInfoRecord u2 = new UserInfoRecord()
 9 {
10       UserName = "翁智华",
11       UserNickName = "Brand",
12       UserAge = 10
13 };
14 Console.WriteLine("ReferenceEquals:" + (ReferenceEquals(u1,u2)), Encoding.GetEncoding("GB2312"));
15 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)继承，如下，我们继承上面的那个记录：

1   /// <summary>
2   ///  继承用户信息record，并扩展Sex属性
3   /// </summary>
4   public record UserInfoRecord2 : UserInfoRecord
5   {
6       public int Sex { get; init; }
7   }

 

对应地，with表达式和基于值的对等性，也相应的结合在一起，下面是继承后，对类型的判断：

1 UserInfoRecord u1 = new UserInfoRecord2()
2  {
3           UserName = "翁智华",
4           UserNickName = "Brand",
5           UserAge = 10,
6           Sex = 1
7  };
8 var u2 = u1 with { UserAge=18  };
9 Console.WriteLine("IsUserInfoRecord2:" + (u2 is UserInfoRecord2)); 

 两个对象在运行时保证了同样的类型的基础上，就可以用基于值的相等来进行比较了：

1  UserInfoRecord u3 = new UserInfoRecord2()
2  {
3          UserName = "翁智华",
4          UserNickName = "Brand",
5          UserAge = 18,
6          Sex = 1
7   };
8   Console.WriteLine("u2 equal u3:" + (u2.Equals(u3)));

 

因为u2之前UserAge改成18了，所以u2跟u3在这边基于值相等，结果如下：

位置记录：Positional Records

使用记录(record)可以明确数据在整个实体中的位置，采用构造函数的参数的方式提供，并且可以通过位置解构提取出数据。

原来我们想要通过构造和解构进行赋值和获取值需要这么写：

 1 /// <summary>
 2 /// 用户信息对象
 3 /// </summary>
 4 public record UInfoRecord
 5 {
 6     public string UserName;
 7     public string NickName;
 8     public int Age;
 9     public UInfoRecord(string userName, string nickName,int age) => (UserName, NickName,Age) = (userName,nickName,age);
10     public void Deconstruct(out string userName,out string nickName,out int age) => (userName, nickName, age) = (UserName, NickName, Age);
11 } 

通过构造来提供内容和通过解构来获取内容：

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

 现在可以通过更加精简的方式完成上面的工作，称为 参数名称包装模式（modulo casing of parameter names），

只要用包装模式声明记录（记录的位置是严格区分的），包含了三个自动属性 ，就可以使用构造函数和解构函数来提供内容和获取内容了，上面的内容可以改写成如下：

1 /// <summary>
2 /// 用户对象
3 /// </summary>
4 public record UInfoRecord(string UserName,string NickName,string Age); 

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

获得的结果是一样的。

如果你想修改默认提供的自动属性，可以自定义的同名属性代替，产生的构造函数和解构函数将会只使用你自定义的那个。如下，重新定义了Age自动属性，并默默的把值+1：

1 /// <summary>
2 /// 用户对象
3 /// </summary>
4 public record UInfoRecord(string UserName, string NickName, int Age)
5 {
6      public int Age { get; init; } = Age+1;
7 }

  

总结

个人感觉record的出现使得对象的使用更加的便捷，一个是对象的复制和使用（with 表达式），不同时间点的数据状态是不一样的；一个是对象的比较（基于值的相等），避免我们进行逐个比较。