如何在 C# 中创建私有可设置的只读结构（例如 Size）？

Question

不确定这是否可以做到，但我需要计算一个大小并将其存储在一个基类中，然后将该结果作为只读方式公开给子类。将 Size 本身设置为只读很容易，只需将其隐藏在具有受保护的 getter 和私有 setter 的属性后面，就像这样......

private Size _someSize;
protected Size SomeSize
{
    get{ return _someSize; }
    private set{ _someSize = value; }
}

然后在基类中，我可以这样设置...

SomeSize = new Size(23.0, 14.7);

...但是我不能从子类中这样做，因为 setter 是基类私有的。

不过，我也不希望子类能够修改 Size 结构的成员。

更新

在子类中，如果你尝试编译这个......

SomeSize.Width = 17.0;

...您将收到错误消息“无法修改 SomeSize 的返回值，因为它不是变量”，因此它确实像我希望的那样保护了基类中的值。

不过，如果有人能弄清楚如何让 getter 返回一个 true 只读结构（如果这样的事情是可能的，我对此表示怀疑），我会给你答案.当然，这个问题实际上并不需要这样做，但知道它是否可以完成仍然是一件好事。

Answer 1

您一定没有尝试编译它，因为您提出的建议已经满足您的需求。 Size 类型是 structure（值类型），而不是 class（引用类型），因此属性 getter 将返回存储在 _someSize 中的值的副本，而不是对它的引用。因此，如果子类实际上试图更改 SomeSize.Width 属性，它实际上不会触及私有 _someSize 变量。它只是更改返回的值的副本。然而，编译器承认这样做是无效的，因此，它甚至不会让下面的行编译：

SomeSize.Width = 17.0;

你可以改变这个值并且仍然让它编译的唯一方法是这样的：

Size temp = SomeSize;
temp.Width = 17.0;

但是，就像我说的那样，因为这只是值的副本，它实际上不会更改 SomeSize 属性的值——它只会更改 temp 的值。

但是，如果Size 类型是一个类，您仍然可以通过简单地返回对象的克隆而不是对原始对象的引用来实现相同的保护。例如，如果Size，实际上是一个看起来像这样的类：

public class MySize
{
    public MySize(float height, float width)
    {
        Height = height;
        Width = width;
    }

    public float Height { get; set; }
    public float Width { get; set; }

    public MySize GetCopy()
    {
        return (MySize)MemberwiseClone();
    }
}

即使它的属性不是只读的，您仍然可以像这样从中创建一个伪只读属性：

private MySize _someSize;
protected MySize SomeSize
{
    get { return _someSize.GetCopy(); }
    private set { _someSize = value; }
}

但是，如果您真的希望返回对象的属性是只读的，那么唯一的方法就是实现您自己的原始类型的只读版本。例如，List<T> 类型支持获取自身只读版本的能力，以便您可以将其用于只读列表属性。因为List<T> 具有该内置功能，您可以轻松地执行以下操作：

private List<string> _list = new List<string>();
public ReadOnlyCollection<string> List
{
    get { return _list.AsReadOnly(); }
}

但是，如您所见，AsReadOnly 方法不会返回 List<T> 对象。相反，它返回一个ReadOnlyCollection 对象，这是一个全新的类型，被定制为列表的只读版本。因此，换句话说，真正创建只读Size 属性的唯一方法是创建自己的ReadOnlySize 类型，如下所示：

public struct ReadOnlySize
{
    public ReadOnlySize(Size size)
    {
        _size = size;
    }

    private Size _size;

    public float Height 
    {
        get { return  _size.Height; } 
    }

    public float Width
    {
        get { return _size.Width; }
    }
}

然后你可以像这样设置你的只读属性：

private Size _someSize;
public ReadOnlySize SomeSize
{
    get { return new ReadOnlySize(_someSize); }
}

Answer 2

.net 语言中结构类型的主要限制之一是，虽然可写结构类型存储位置（变量、字段、参数、数组槽等）的字段本身是可写存储位置（如果它们是结构类型，它们的字段同样是可写的存储位置），这种访问仅适用于结构类型存储位置，并且除了System.Array之外的任何类型都无法公开属性，就像一个存储位置。

如果一个类提供了一种方法，该方法可以将该存储位置作为ref 参数传递给提供的回调，则该类可以将私有存储位置公开为受控情况下的存储位置。

例如：

public delegate void ActByRef<T1>(ref T1 p1);
public delegate void ActByRef<T1,T2>(ref T1 p1, ref T2 p2);
public delegate void ActByRef<T1,T2,T3>(ref T1 p1, ref T2 p2, ref T3 p3);

public void ActOnSize(ActByRef proc) 
  { proc( ref _someSize); }
public void ActOnSize<XT1>(ActByRef proc, ref XT1 xp1) 
  { proc( ref _someSize, ref xp1); }
public void ActOnSize<XT1,XT2>(ActByRef proc, ref XT1 xp1, ref XT2 xp2)
  { proc( ref _someSize, ref xp1, ref xp2); }

如果想在暴露了这种方法的东西的宽度上增加 5，那么可以使用

thing.ActOnSize((ref Size sz) => sz.Width += 5);

如果有一个局部变量“HeightAdder”，并且希望将其添加到对象的高度，可以使用

thing.ActOnSize((ref Size sz, ref int adder) =>
  sz.Height += adder, ref HeightAdder);

请注意，由于编写的 lambda 表达式不会捕获任何局部变量，因此可以将其作为静态委托进行评估（如果委托已将 HeightAdder，而不是 ref 参数 adder 添加到高度，则每次进入作用域时都需要生成一个闭包来保存HeightAdder，并且每次执行方法调用时都需要生成一个委托；将数量作为ref 参数传递可以避免这种开销）。

如果访问方法包含索引或键的参数，类似List<T> 或Dictionary<TKey,TValue> 的类可以使用类似的方法来允许回调方法直接作用于列表槽或字典条目。

这种方法的一个很好的特点是它允许集合提供并发访问的样式，而这在其他情况下是很困难的。如果集合中的事物属于可以与Interlocked 方法一起使用的类型（或者是其字段可用于此类方法的公开结构类型），则客户端代码可以使用此类方法在基础数据。如果集合中的事物不是这种类型，那么集合可能能够比其他方法更安全地实现锁定。例如，ConcurrentIndexedSet<T> 可能有一个 ActOnItem(int item, int timeout, ActByRef<T> proc) 家族；将在锁内的项目上调用proc 的方法（相信客户端提供的proc 可以被信任在合理的时间范围内返回）。虽然此类代码无法防止 proc 陷入死锁或以其他方式被搁置的可能性，但它可以确保在将控制权返回给调用代码之前释放锁。