8

我发现自己必须创建很多不可变的类，并且我想找到一种没有多余信息的方法。我不能使用匿名类型，因为我需要从方法中返回这些类。我想要智能感知支持，所以我不想使用字典、动态或类似的东西。我还想要名称良好的属性，它排除了 Tuple<>。到目前为止，我尝试过的一些模式：

// inherit Tuple<>. This has the added benefit of giving you Equals() and GetHashCode()
public class MyImmutable : Tuple<int, string, bool> {
   public MyImmutable(int field1, string field2, bool field3) : base(field1, field2, field3) { }

   public int Field1 { get { return this.Item1; } }
   public string Field2 { get { return this.Item2; } }
   public bool Field3 { get { return this.Item3; } }
}

///////////////////////////////////////////////////////////////////////////////////

// using a custom SetOnce<T> struct that throws an error if set twice or if read before being set
// the nice thing about this approach is that you can skip writing a constructor and 
// use object initializer syntax.
public class MyImmutable {
    private SetOnce<int> _field1;
    private SetOnce<string> _field2;
    private SetOnce<bool> _field3;


   public int Field1 { get { return this._field1.Value; } set { this._field1.Value = value; }
   public string Field2 { get { return this._field2.Value; } set { this._field2.Value = value; }
   public bool Field3 { get { return this._field3.Value; } set { this._field3.Value = value; }
}

///////////////////////////////////////////////////////////////////////////////////

// EDIT: another idea I thought of: create an Immutable<T> type which allows you to
// easily expose types with simple get/set properties as immutable
public class Immutable<T> {
    private readonly Dictionary<PropertyInfo, object> _values;       

    public Immutable(T obj) {
        // if we are worried about the performance of this reflection, we could always statically cache
        // the getters as compiled delegates
        this._values = typeof(T).GetProperties()
            .Where(pi => pi.CanRead)
            // Utils.MemberComparer is a static IEqualityComparer that correctly compares
            // members so that ReflectedType is ignored
            .ToDictionary(pi => pi, pi => pi.GetValue(obj, null), Utils.MemberComparer);
    }

    public TProperty Get<TProperty>(Expression<Func<T, TProperty>> propertyAccessor) {
        var prop = (PropertyInfo)((MemberExpression)propertyAccessor.Body).Member;
        return (TProperty)this._values[prop];
    }
}

// usage
public class Mutable { int A { get; set; } }

// we could easily write a ToImmutable extension that would give us type inference
var immutable = new Immutable<Mutable>(new Mutable { A = 5 });
var a = immutable.Get(m => m.A);

// obviously, this is less performant than the other suggestions and somewhat clumsier to use.
// However, it does make declaring the immutable type quite concise, and has the advantage that we can make
// any mutable type immutable

///////////////////////////////////////////////////////////////////////////////////

// EDIT: Phil Patterson and others mentioned the following pattern
// this seems to be roughly the same # characters as with Tuple<>, but results in many
// more lines and doesn't give you free Equals() and GetHashCode()
public class MyImmutable 
{
   public MyImmutable(int field1, string field2, bool field3)
   {
        Field1 = field1;
        Field2 = field2;
        Field3 = field3;
   }

   public int Field1 { get; private set; }
   public string Field2 { get; private set; }
   public bool Field3 { get; private set; }
}

这些都比创建只读字段、通过构造函数设置它们并通过属性公开它们的“标准”模式稍微简单一些。然而，这两种方法仍然有很多冗余的样板。

有任何想法吗？

4

3 回答 3

4

您可以将自动属性与私有设置器一起使用

public class MyImmutable 
{
   public MyImmutable(int field1, string field2, bool field3)
   {
        Field1 = field1;
        Field2 = field2;
        Field3 = field3;
   }

   public int Field1 { get; private set; }
   public string Field2 { get; private set; }
   public bool Field3 { get; private set; }
}
于 2013-03-07T22:42:09.590 回答
1

查看public {get;private set;}属性是否适用于您的情况 - 比单独的字段声明更紧凑，语义完全相同。

更新：正如 ChaseMedallion 在问题中评论和内联的那样，这种方法不提供与方法不同的自动生成GetHashCode和方法。EqualsTuple

class MyImmutable 
{
    public int MyProperty {get; private set;}

    public MyImmutable(int myProperty)
    {
       MyProperty = v;
    }
}

我喜欢Tuple这种方法，因为它提供了可以在有趣的上下文中安全使用的对象并提供了好听的名称。如果我需要创建许多这样的类型，我会考虑重新实现Tuple类：

  • 在构建时预先计算GetHashCode 并存储为对象的一部分，以避免对集合/字符串进行无界检查。可能是可选的，以允许选择在Dictionary.
  • 隐藏通用名称（即或仅使用EditorBrowsableAttributeprotected隐藏智能），因此不会混淆 2 组名称。
  • 考虑在调试构建/FxCop 规则中强制字段类型不可变...

旁注：查看 Eric Lippert关于不可变类型的系列。

于 2013-03-07T22:41:56.327 回答
1

当存在相应的可变类时，不可变类最有用，该类的内容可以轻松地从不可变类型实例加载或复制到新的不可变类型实例。如果一个不可变对象需要对其进行超过 2-3 次“更改”（即更改引用，使其指向与原始对象不同的不可变对象），则将数据复制到可变对象，更改它，并将其存储回来通常比创建一个以某种方式与原始对象不同的对象，然后创建一个以另一种方式不同于该对象的新对象等更实用。

一个很好的易于概括的方法是定义一个（可能是内部的）暴露字段结构类型，然后让可变和不可变类都保存该类型的字段。必须为两种类类型分别定义访问器属性，但可以同时将类型GetHashCode和Equals方法都链接到底层结构的相应方法。在给定另一个实例的情况下创建任何一种类型的实例都可以使用单个结构赋值来完成，而不必单独复制所有成员。

如果一个程序员了解结构的工作原理（我认为这种知识是基础知识，即使其他人不同意），那么可以将结构类型公开。即使结构是公共的，拥有一个可变持有者类也可能很有用，因为有时引用语义很有用（例如，人们可能希望能够更改存储在 a 中的某些内容Dictionary而不必更改其Dictionary本身），但是转换to-mutable/change/convert-to-immutable 模式在结构类型上比在类类型上效果更好。

于 2013-03-12T17:14:14.350 回答