C# 中的通用不可变类

Question

我正在用 C# 编写函数式代码。我的许多类都是不可变的，具有返回实例的修改副本的方法。

例如：

sealed class A
{
    readonly X x;
    readonly Y y;

    public class A(X x, Y y)
    {
        this.x = x;
        this.y = y;
    }

    public A SetX(X nextX)
    {
        return new A(nextX, y);
    }

    public A SetY(Y nextY)
    {
        return new A(x, nextY);
    }
}

这是一个简单的例子，但是想象一个更大的类，有更多的成员。

问题在于构建这些修改后的副本非常冗长。大多数方法只更改一个值，但我必须将 all 未更改的值传递给构造函数。

在使用修饰符方法构造不可变类时，是否有一种模式或技术可以避免所有这些样板？

注意：我不想将struct 用于reasons discussed elsewhere on this site。

---

更新：我后来发现这在 F# 中被称为“复制和更新记录表达式”。

Answer 1

对于较大的类型，我将构建一个 With 函数，该函数的参数默认为 null（如果未提供）：

public sealed class A
{
    public readonly X X;
    public readonly Y Y;

    public A(X x, Y y)
    {
        X = x;
        Y = y;
    }

    public A With(X X = null, Y Y = null) =>
        new A(
            X ?? this.X,
            Y ?? this.Y
        );
}

然后使用 C# 的命名参数功能：

val = val.With(X: x);

val = val.With(Y: y);

val = val.With(X: x, Y: y);

我发现 int 方法比许多 setter 方法更有吸引力。这确实意味着null 成为一个不可用的值，但是如果您要走功能路线，那么我假设您也试图避免null 并使用选项。

如果您有值类型/结构作为成员，则在 With 中将它们设为 Nullable，例如：

public sealed class A
{
    public readonly int X;
    public readonly int Y;

    public A(int x, int y)
    {
        X = x;
        Y = y;
    }

    public A With(int? X = null, int? Y = null) =>
        new A(
            X ?? this.X,
            Y ?? this.Y
        );
}

但是请注意，这不是免费的，每次调用With 都会有N 空比较操作，其中N 是参数的数量。我个人认为这种便利值得付出代价（最终可以忽略不计），但是如果你有任何对性能特别敏感的东西，那么你应该回退到定制的 setter 方法。

如果你觉得写With函数太乏味，那么你可以使用我的open-source C# functional programming library: language-ext。上面可以这样完成：

[With]
public partial class A
{
    public readonly int X;
    public readonly int Y;

    public A(int x, int y)
    {
        X = x;
        Y = y;
    }
}

您必须在项目中包含LanguageExt.Core 和LanguageExt.CodeGen。 LanguageExt.CodeGen 不需要包含在项目的最终版本中。

[Record] 属性带来了最后一点便利：

[Record]
public partial class A
{
    public readonly int X;
    public readonly int Y;
}

它将构建With 函数，以及您的构造函数、解构函数、结构相等、结构排序、镜头、GetHashCode 实现、ToString 实现和序列化/反序列化。

Here's an overview of all of the Code-Gen features

Answer 2

对此有一个优雅有效的解决方案 - 请参阅项目 With

有了With，你的班级可以简单地变成：

sealed class A : IImmutable 
{
    public readonly X x;
    public readonly Y y;

    public class A(X x, Y y)
    {
        this.x = x;
        this.y = y;
    }
}

你可以这样做：

using System.Immutable;
var o = new A(0, 0);
var o1 = o.With(a => a.y, 5);

Answer 3

我会将构建器模式与一些扩展方法结合使用。基本思路是有一个ToBuilder方法将A初始化为ABuilder，使用流畅的接口修改builder，然后完成builder得到新的实例。在某些情况下，这种方法甚至可以减少垃圾。

不可变类：

public sealed class A
{
    readonly int x;

    public int X
    {
        get { return x; }
    }

    public A(int x)
    {
        this.x = x;
    }
}

构建器类：

public sealed class ABuilder
{
    public int X { get; set; }

    public ABuilder(A a)
    {
        this.X = a.X;
    }

    public A Build()
    {
        return new A(X);
    }
}

有用的扩展方法：

public static class Extensions
{
    public static ABuilder With(this ABuilder builder, Action<ABuilder> action)
    {
        action(builder);

        return builder;
    }

    public static ABuilder ToBuilder(this A a)
    {
        return new ABuilder(a) { X = a.X };
    }
}

它是这样使用的：

var a = new A(10);

a = a.ToBuilder().With(i => i.X = 20).Build();

这并不完美。您需要使用原始类型的所有属性定义一个额外的类，但使用语法非常简洁，并且保持了原始类型的简单性。

Answer 4

对于这个确切的情况，我使用Object. MemberwiseClone()。该方法仅适用于直接属性更新（因为浅克隆）。

sealed class A 
{
    // added private setters for approach to work
    public X x { get; private set;} 
    public Y y { get; private set;} 

    public class A(X x, Y y) 
    { 
        this.x = x; 
        this.y = y; 
    } 

    private A With(Action<A> update) 
    {
        var clone = (A)MemberwiseClone();
        update(clone);
        return clone;
    } 

    public A SetX(X nextX) 
    { 
        return With(a => a.x = nextX); 
    } 

    public A SetY(Y nextY) 
    { 
        return With(a => a.y = nextY); 
    } 
 }

Answer 5

您可以使用以下模式（不知道它是否通过，但您要求较少冗余的版本，无论如何您可能会有所了解）：

 public class Base
    {
        public int x { get; protected set; }
        public int y { get; protected  set; }

        /// <summary>
        /// One constructor which set all properties
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public Base(int x, int y)
        {
            this.x = x;
            this.y = y;
        }

        /// <summary>
        /// Constructor which init porperties from other class
        /// </summary>
        /// <param name="baseClass"></param>
        public Base(Base baseClass) : this(baseClass.x, baseClass.y)
        {
        }

        /// <summary>
        ///  May be more secured constructor because you always can check input parameter for null
        /// </summary>
        /// <param name="baseClass"></param>
        //public Base(Base baseClass)
        //{
        //    if (baseClass == null)
        //    {
        //        return;
        //    }

        //    this.x = baseClass.x;
        //    this.y = baseClass.y;
        //}
    }

    public sealed class A : Base
    {
        // Don't know if you really need this one
        public A(int x, int y) : base(x, y)
        {
        }

        public A(A a) : base(a)
        {
        }

        public A SetX(int nextX)
        {
            // Create manual copy of object and then set another value
            var a = new A(this)
            {
                x = nextX
            };

            return a;
        }

        public A SetY(int nextY)
        {
            // Create manual copy of object and then set another value
            var a = new A(this)
            {
                y = nextY
            };

            return a;
        }
    }

这样，您可以通过传递现有对象的引用来减少 A 的构造函数中的参数数量，设置所有属性，然后在某个 A 方法中只设置一个新的。