这些东西的一致性很重要，我喜欢遵循Swift API设计指南中的命名约定:

Name functions and methods according to their side-effects Those without side-effects should read as noun phrases, e.g. x.distance(to: y), i.successor(). Those with side-effects should read as imperative verb phrases, e.g., print(x), x.sort(), x.append(y). Name mutating/non-mutating method pairs consistently. A mutating method will often have a non-mutating variant with similar semantics, but that returns a new value rather than updating an instance in-place. When the operation is naturally described by a verb, use the verb’s imperative for the mutating method and apply the “ed” or “ing” suffix to name its non-mutating counterpart. Mutating Non-mutating x.sort() z = x.sorted() x.append(y) z = x.appending(y) When the operation is naturally described by a noun, use the noun for the non-mutating method and apply the “form” prefix to name its mutating counterpart. Non-mutating Mutating x = y.union(z) y.formUnion(z) j = c.successor(i) c.formSuccessor(&i)

因为该方法的变异版本是Add，所以非变异版本可以是Added或Adding:

// Note that following the convention results in code being written as english sentences
var empty = new ImmutableList<string>();
var list1 = empty.Adding("Hello");
var list2 = list1.Adding("immutable"); // `list2` is equal to `list1` adding "immutable"
var list3 = list2.Adding("word");

也许混淆源于您想要两个操作合一的事实。为什么不把它们分开呢?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())
);

WithAdded这个名字读起来很好，在我看来比Added要好，它可以被理解为一个形容词。

var list2 = list1.WithAdded("immutable");

或者是稍微啰嗦一点的版本:

var list2 = list1.WithAddedElement("immutable");

我把它叫做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);

我会用运算符重载+。原因是这就是它在Python中的工作方式-列表上的.append()会改变列表，而对另一个列表执行+则会创建一个新列表。+也绝不意味着突变。我想这就是为什么你这么喜欢. plus()，所以如果你不想操作符过载，那么你可以使用. plus()。

我会使用list. newlist(“word”)，因为它描述了你正在做的事情(创建一个新列表)。

我必须同意，这并不意味着参数被添加到列表的末尾，但就我个人而言，我属于简洁的阵营，所以我更喜欢list. newlist ("word")而不是list. newlistafterappend ("word")。