C# 9.0新特性详解系列之五：记录(record)和with表达式

时间  2020-12-10
标签 web 编程 api 安全 数据结构 多线程 并发 app ide 函数 栏目 C# 繁體版
原文   原文链接

1 背景与动机

传统面向对象编程的核心思想是一个对象有着惟一标识，表现为对象引用，封装着随时可变的属性状态，若是你改变了一个属性的状态，这个对象仍是原来那个对象，就是对象引用没有由于状态的改变而改变，也就是说该对象能够有不少种状态。C#从最初开始也是一直这样设计和工做的。可是一些时候，你可能很是须要一种刚好相反的方式，例如我须要一个对象只有一个状态，那么原来那种默认方式每每会成为阻力，使得事情变得费时费力。web

当一个类型的对象在建立时被指定状态后，就不会再变化的对象，咱们称之为不可变类型。这种类型是线程安全的，不须要进行线程同步，很是适合并行计算的数据共享。它减小了更新对象会引发各类bug的风险，更为安全。System.DateTime和string就是不可变类型很是经典的表明。编程

原来，咱们要用类来建立一个不可变类型，你首先要定义只读字段和属性，而且还要重写涉及相等判断的方法等。在C#9.0中，引入了record，专门用来以最简的方式建立不可变类型的新方式。若是你须要一个行为像值类型的引用类型，你可使用record；若是你须要整个对象都是不可变的，且行为像一个值，那么你也可考虑将其声明为一个record类型。 那么什么是record类型？api

2 Record介绍

record类型是一种用record关键字声明的新的引用类型，与类不一样的是，它是基于值相等而不是惟一的标识符——对象引用。他有着引用类型的支持大对象、继承、多态等特性，也有着结构的基于值相等的特性。能够说有着class和struct二者的优点，在一些状况下能够用以替代class和struct。安全

提到不可变的类型，咱们会想到readonly struct，那么为何要选择添加一个新的类型，而不是用readonly struct呢？这是由于记录有着以下优势：数据结构

  • 在构造不可变的数据结构时，它的语法简单易用。多线程

  • record为引用类型，不用像值类型在传递时须要内存分配，并进行总体拷贝。并发

  • 构造函数和结构函数为一体的、简化的位置记录app

  • 有力的相等性支持，重写了Equals(object), IEquatable , 和GetHashCode()这些基本方法。 ide

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来替换写一个类。未知的还在等咱们进一步探索。

如对您有价值，请推荐，您的鼓励是我继续的动力，在此万分感谢。关注本人公众号“码客风云”，享第一时间阅读最新文章。

码客风云
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程