我把它叫做ToInclude

var empty = new ImmutableList<string>();
var list1 = empty.ToInclude("Hello");
var list2 = list1.ToInclude("immutable");
var list3 = list2.ToInclude("word");

惯用地(?)

var list = new ImmutableList<string>().ToInclude("Hello");
                                      .ToInclude("immutable");
                                      .ToInclude("word");

对你提到的案子也适用。

var list = new ImmutableList<string>();list.ToInclude("foo");

var suite = new TestSuite<string, int>();suite.ToInclude(x => x.Length);

也许混淆源于您想要两个操作合一的事实。为什么不把它们分开呢?DSL风格:

var list = new ImmutableList<string>("Hello");
var list2 = list.Copy().With("World!");

Copy会返回一个中间对象，这是原始列表的可变副本。With将返回一个新的不可变列表。

更新:

但是，使用中间的、可变的集合并不是一个好方法。中间对象应该包含在Copy操作中:

var list1 = new ImmutableList<string>("Hello");
var list2 = list1.Copy(list => list.Add("World!"));

现在，Copy操作接受一个委托，该委托接收一个可变列表，因此它可以控制复制结果。它能做的远不止追加一个元素，比如删除元素或对列表排序。它还可以在ImmutableList构造函数中使用，在没有中间不可变列表的情况下组装初始列表。

public ImmutableList<T> Copy(Action<IList<T>> mutate) {
  if (mutate == null) return this;
  var list = new List<T>(this);
  mutate(list);
  return new ImmutableList<T>(list);
}

现在不存在被用户误解的可能性，他们自然会掉进成功的坑里。

还有一个更新:

如果你仍然不喜欢提到可变列表，即使现在包含了它，你可以设计一个规范对象，它将指定或脚本，复制操作将如何转换它的列表。用法是一样的:

var list1 = new ImmutableList<string>("Hello");
// rules is a specification object, that takes commands to run in the copied collection
var list2 = list1.Copy(rules => rules.Append("World!"));

现在你可以对规则名称进行创新，你可以只公开你想要Copy支持的功能，而不是IList的全部功能。

对于链接的使用，你可以创建一个合理的构造函数(当然，它不会使用链接):

public ImmutableList(params T[] elements) ...

...

var list = new ImmutableList<string>("Hello", "immutable", "World");

或者在其他构造函数中使用相同的委托:

var list = new ImmutableList<string>(rules => 
  rules
    .Append("Hello")
    .Append("immutable")
    .Append("World")
);

这里假设规则。Append方法返回这个。

这是你最新的例子的样子:

var suite = new TestSuite<string, int>(x => x.Length);
var otherSuite = suite.Copy(rules => 
  rules
    .Append(x => Int32.Parse(x))
    .Append(x => x.GetHashCode())
);

“添加()”

它返回一个新列表的事实是无关紧要的，这是签名所揭示的实现细节。该方法完成的主要操作是向列表中“添加”一个新元素。它如何执行或返回什么不应该是方法名称的一部分。如果一个方法是同步的，是否会影响方法名-"synchronizedAdd()"?？? -当然不是。

像String这样的类遵循可能的突变模式，仍然有非常简单的方法名——没有一个是复合词。

“替代”?它不会添加到列表中，而是用一个新的列表替换该列表。

游戏开始得很晚，但是《冰雪奇缘》怎么样。在WPF中，使用Freeze和IsFrozen来测试对象是否可变是有优先级的。当然，这有点扭曲了意义，因为通常Freeze()是一种使当前对象不可变的方法，但如果它有一个参数，您可以看到您得到的是不可变的东西。

var list = new ImmutableList<string>().Freeze("Hello")
                                      .Freeze("Fridgid")
                                      .Freeze("World");

基本上:

这是一个词 其内涵围绕着不变性展开。 WPF中“相似”语法的优先级。

任何暗示将返回相同类型的对象的名称都可以使用。Plus是一个很好的名称，就好像你加了两个对象，希望返回结果。

不过，在这种情况下，Plus听起来不像是使用的正确名称，因为您正在将一个测试“Plus”到一个测试套件中。

对我来说，GetWith()听起来像是一个选项。或者GetTypeWith()，其中类型显然是您使用的类型。例如:

var list = new ImmutableList<String>();
var list2 = list.GetWith("First");
var list3 = list2.GetWith("Second");

// OR

var list2 = list.GetListWith("First");

Get表示您正在获取已经包含的列表，With表示您还需要另一个对象。CopyWith()也符合这个标准。

我认为GetWith的直接问题是它不容易被猜测。开发人员想要添加一个套件，而不是获得当前的套件。我会立即输入。add，希望情报显示的东西非常接近我的预期。