什么是“基本完整”？ (im)C# 的可变性方法？

Question

Closed. This question needs to be more focused. It is not currently accepting answers.

---

想要改进这个问题吗？通过编辑这篇文章来更新问题，使其仅关注一个问题。

7 年前已关闭。

Answer 1

更好的解决方案是在需要真正不变性的地方使用 F# 吗？

Answer 2

使用我整理的这个 T4 模板 来解决这个问题。它通常应该满足您需要创建的任何类型的不可变对象的需求。

无需使用泛型或使用任何接口。出于我的目的，我不希望我的不可变类可以相互转换。你为什么要这么做？他们应该具有哪些共同特征才能使他们可以相互转换？强制执行代码模式应该是代码生成器的工作（或者更好的是，一个足够好的类型系统允许您定义通用代码模式，不幸的是 C# 没有）。

下面是模板的一些示例输出，用于说明基本概念（不用介意用于属性的类型）：

public sealed partial class CommitPartial
{
    public CommitID ID { get; private set; }
    public TreeID TreeID { get; private set; }
    public string Committer { get; private set; }
    public DateTimeOffset DateCommitted { get; private set; }
    public string Message { get; private set; }

    public CommitPartial(Builder b)
    {
        this.ID = b.ID;
        this.TreeID = b.TreeID;
        this.Committer = b.Committer;
        this.DateCommitted = b.DateCommitted;
        this.Message = b.Message;
    }

    public sealed class Builder
    {
        public CommitID ID { get; set; }
        public TreeID TreeID { get; set; }
        public string Committer { get; set; }
        public DateTimeOffset DateCommitted { get; set; }
        public string Message { get; set; }

        public Builder() { }

        public Builder(CommitPartial imm)
        {
            this.ID = imm.ID;
            this.TreeID = imm.TreeID;
            this.Committer = imm.Committer;
            this.DateCommitted = imm.DateCommitted;
            this.Message = imm.Message;
        }

        public Builder(
            CommitID pID
           ,TreeID pTreeID
           ,string pCommitter
           ,DateTimeOffset pDateCommitted
           ,string pMessage
        )
        {
            this.ID = pID;
            this.TreeID = pTreeID;
            this.Committer = pCommitter;
            this.DateCommitted = pDateCommitted;
            this.Message = pMessage;
        }
    }

    public static implicit operator CommitPartial(Builder b)
    {
        return new CommitPartial(b);
    }
}

基本模式是拥有一个不可变类，其中包含一个嵌套可变 Builder 类，该类用于以可变方式构造不可变类的实例。设置不可变类属性的唯一方法是构造一个 ImmutableType.Builder 类，并以正常的可变方式设置它，并使用隐式方法将其转换为包含它的 ImmutableType 类。转换运算符。

您可以扩展 T4 模板，向 ImmutableType 类本身添加一个默认的公共构造函数，这样如果您可以预先设置所有属性，就可以避免双重分配。

以下是用法示例：

CommitPartial cp = new CommitPartial.Builder() { Message = "Hello", OtherFields = value, ... };

或...

CommitPartial.Builder cpb = new CommitPartial.Builder();
cpb.Message = "Hello";
...
// using the implicit conversion operator:
CommitPartial cp = cpb;
// alternatively, using an explicit cast to invoke the conversion operator:
CommitPartial cp = (CommitPartial)cpb;

请注意，在赋值中使用了从 CommitPartial.Builder 到 CommitPartial 的隐式转换运算符。这就是通过使用正常复制语义构造一个新的不可变 CommitPartial 实例来“冻结”可变 CommitPartial.Builder 的部分。

Answer 3

就我个人而言，我并不真正了解这个问题的任何第三方或以前的解决方案，因此，如果我涉及旧问题，我深表歉意。但是，如果我要为我正在从事的项目实现某种不变性标准，我会从这样的开始：

public interface ISnaphot<T>
{
    T TakeSnapshot();
}

public class Immutable<T> where T : ISnaphot<T>
{
    private readonly T _item;
    public T Copy { get { return _item.TakeSnapshot(); } }

    public Immutable(T item)
    {
        _item = item.TakeSnapshot();
    }
}

该接口将实现如下所示：

public class Customer : ISnaphot<Customer>
{
    public string Name { get; set; }
    private List<string> _creditCardNumbers = new List<string>();
    public List<string> CreditCardNumbers { get { return _creditCardNumbers; } set { _creditCardNumbers = value; } }

    public Customer TakeSnapshot()
    {
        return new Customer() { Name = this.Name, CreditCardNumbers = new List<string>(this.CreditCardNumbers) };
    }
}

客户端代码将类似于：

    public void Example()
    {
        var myCustomer = new Customer() { Name = "Erik";}
        var myImmutableCustomer = new Immutable<Customer>(myCustomer);
        myCustomer.Name = null;
        myCustomer.CreditCardNumbers = null;

        //These guys do not throw exceptions
        Console.WriteLine(myImmutableCustomer.Copy.Name.Length);
        Console.WriteLine("Credit card count: " + myImmutableCustomer.Copy.CreditCardNumbers.Count);
    }

明显的缺陷是该实现仅与 ISnapshot 的 TakeSnapshot 实现的客户端一样好，但至少它可以标准化事物，并且如果您有与可疑的可变性相关的问题。潜在的实现者也有责任认识到他们是否可以提供快照不变性并且不实现该接口，如果不能（即该类返回对不支持任何类型的克隆/复制的字段的引用，因此不能被快照版）。

正如我所说，这是一个开始——我可能会这样开始——当然不是一个最佳的解决方案或一个完成的、完美的想法。从这里，我会看到我的用法是如何演变的，并相应地修改这种方法。但是，至少在这里我知道我可以定义如何使某些东西不可变并编写单元测试以确保它是不可变的。

我意识到这与实现对象复制相差不远，但它标准化了复制与不可变性。在代码库中，您可能会看到一些 ICloneable 实现者、一些复制构造函数和一些显式复制方法，甚至可能在同一个类中。定义这样的东西会告诉你，意图与不变性特别相关——我想要一个快照而不是一个重复的对象，因为我碰巧想要n个该对象。 Immtuable 类还集中了不变性和副本之间的关系；如果您稍后想要以某种方式进行优化，例如缓存快照直到变脏，则无需在复制逻辑的所有实现器中执行此操作。

Answer 4

如果目标是让对象充当非共享的可变对象，但可以在这样做时共享以提高效率，那么我建议使用私有的、可变的“基本数据”类型。尽管任何持有这种类型对象引用的人都能够改变它，但这样的引用永远不会逃脱程序集。对数据的所有外部操作都必须通过包装对象来完成，每个包装对象都拥有两个引用：

1. UnsharedVersion - 拥有对其内部数据对象的唯一引用，并且可以自由修改它
2. SharedImmutableVersion——保存对数据对象的引用，除了其他 SharedImmutableVersion 字段之外，不存在对该数据对象的引用；此类对象可能是可变类型，但实际上是不可变的，因为不会向会改变它们的代码提供任何引用。

可以填充一个或两个字段；当两者都填充时，它们应该引用具有相同数据的实例。

如果尝试通过包装器改变对象并且 UnsharedVersion 字段为 null，则 SharedImmutableVersion 中对象的克隆应存储在 UnsharedVersion 中。接下来，应清除 SharedImmutableCVersion，并根据需要更改 UnsharedVersion 中的对象。

如果尝试克隆一个对象，并且 SharedImmutableVersion 为空，则 UnsharedVersion 中的对象克隆应存储到 SharedImmutableVersion 中。接下来，应构造一个新的包装器，其 UnsharedVersion 字段为空，其 SharedImmutableVersion 字段填充有原始的 SharedImmutableVersion 字段。

如果多个克隆是由一个对象直接或间接组成的，并且该对象在这些克隆的构造之间没有发生变化，那么所有克隆都将引用同一个对象实例。然而，这些克隆中的任何一个都可能发生突变，而不会影响其他克隆。任何此类突变都会生成一个新实例并将其存储在 UnsharedVersion 中。