'readonly' 修饰符是否会创建字段的隐藏副本？

Question

MutableSlab 和ImmutableSlab 实现之间的唯一区别是readonly 修饰符应用于handle 字段：

using System;
using System.Runtime.InteropServices;

public class Program
{
    class MutableSlab : IDisposable
    {
        private GCHandle handle;

        public MutableSlab()
        {
            this.handle = GCHandle.Alloc(new byte[256], GCHandleType.Pinned);
        }

        public bool IsAllocated => this.handle.IsAllocated;

        public void Dispose()
        {
            this.handle.Free();
        }
    }

    class ImmutableSlab : IDisposable
    {
        private readonly GCHandle handle;

        public ImmutableSlab()
        {
            this.handle = GCHandle.Alloc(new byte[256], GCHandleType.Pinned);
        }

        public bool IsAllocated => this.handle.IsAllocated;

        public void Dispose()
        {
            this.handle.Free();
        }
    }

    public static void Main()
    {
        var mutableSlab = new MutableSlab();
        var immutableSlab = new ImmutableSlab();

        mutableSlab.Dispose();
        immutableSlab.Dispose();

        Console.WriteLine($"{nameof(mutableSlab)}.handle.IsAllocated = {mutableSlab.IsAllocated}");
        Console.WriteLine($"{nameof(immutableSlab)}.handle.IsAllocated = {immutableSlab.IsAllocated}");
    }
}

但它们会产生不同的结果：

mutableSlab.handle.IsAllocated = False
immutableSlab.handle.IsAllocated = True

GCHandle 是一个可变结构，当您复制它时，它的行为与 immutableSlab 的场景完全相同。

readonly 修饰符是否会创建字段的隐藏副本？这是否意味着它不仅仅是编译时检查？我找不到有关此行为的任何信息here。是否记录了这种行为？

Answer 1

readonly 修饰符是否会创建字段的隐藏副本？

在常规结构类型（在构造函数或静态构造函数之外）的只读字段上调用方法或属性首先复制该字段，是的。那是因为编译器不知道属性或方法访问是否会修改您调用它的值。

来自C# 5 ECMA specification：

第 12.7.5.1 节（会员访问，一般）

这对成员访问进行分类，包括：

• 如果我识别出一个静态字段：
  • 如果该字段是只读的并且引用发生在声明该字段的类或结构的静态构造函数之外，则结果是一个值，即E中的静态字段I的值。
  • 否则结果为变量，即E中的静态字段I。

还有：

• 如果 T 是一个结构类型并且 I 标识了该结构类型的一个实例字段：
  • 如果 E 是一个值，或者如果该字段是只读的并且引用发生在声明该字段的结构的实例构造函数之外，则结果是一个值，即结构中字段 I 的值E 给出的实例。
  • 否则结果为变量，即E给定的struct实例中的字段I。

我不确定为什么实例字段部分专门引用结构类型，但静态字段部分没有。重要的部分是表达式是分类为变量还是值。这在函数成员调用中很重要......

第 12.6.6.1 节（函数成员调用，一般）

函数成员调用的运行时处理包括以下步骤，其中 M 是函数成员，如果 M 是实例成员，则 E 是实例表达式：

[...]

• 否则，如果 E 的类型是值类型 V，并且在 V 中声明或覆盖了 M：
  • [...]
  • 如果 E 未被分类为变量，则创建 E 类型的临时局部变量并将 E 的值分配给该变量。然后将 E 重新分类为对该临时局部变量的引用。临时变量可以在 M 中作为 this 访问，但不能以任何其他方式访问。因此，只有当 E 是一个真正的变量时，调用者才有可能观察到 M 对此所做的更改。

这是一个独立的例子：

using System;
using System.Globalization;

struct Counter
{
    private int count;

    public int IncrementedCount => ++count;
}

class Test
{
    static readonly Counter readOnlyCounter;
    static Counter readWriteCounter;

    static void Main()
    {
        Console.WriteLine(readOnlyCounter.IncrementedCount);  // 1
        Console.WriteLine(readOnlyCounter.IncrementedCount);  // 1
        Console.WriteLine(readOnlyCounter.IncrementedCount);  // 1

        Console.WriteLine(readWriteCounter.IncrementedCount); // 1
        Console.WriteLine(readWriteCounter.IncrementedCount); // 2
        Console.WriteLine(readWriteCounter.IncrementedCount); // 3
    }
}

这是调用 readOnlyCounter.IncrementedCount 的 IL：

ldsfld     valuetype Counter Test::readOnlyCounter
stloc.0
ldloca.s   V_0
call       instance int32 Counter::get_IncrementedCount()

将字段值复制到堆栈上，然后调用属性...因此字段的值不会最终改变；它在副本中递增count。

将其与读写字段的 IL 进行比较：

ldsflda    valuetype Counter Test::readWriteCounter
call       instance int32 Counter::get_IncrementedCount()

这会直接在字段上进行调用，因此字段值最终会在属性内发生变化。

当结构很大并且成员没有改变它时，复制可能效率低下。这就是为什么在 C# 7.2 及更高版本中，readonly 修饰符可以应用于结构。这是另一个例子：

using System;
using System.Globalization;

readonly struct ReadOnlyStruct
{
    public void NoOp() {}
}

class Test
{
    static readonly ReadOnlyStruct field1;
    static ReadOnlyStruct field2;

    static void Main()
    {
        field1.NoOp();
        field2.NoOp();
    }
}

使用结构本身的readonly 修饰符，field1.NoOp() 调用不会创建副本。如果您删除 readonly 修饰符并重新编译，您会看到它创建了一个副本，就像在 readOnlyCounter.IncrementedCount 中所做的一样。

我写了一个blog post from 2014，发现readonly 字段导致Noda Time 出现性能问题。幸运的是，现在改用结构上的 readonly 修饰符解决了这个问题。