我知道什么时候会返回 IEnumerable来自方法——当延迟执行有值(value)时。并返回 List或 IList几乎应该只在结果要被修改时才会出现，否则我会返回一个 IReadOnlyCollection ，所以调用者知道他得到的不是要修改的(这使得该方法甚至可以重用来自其他调用者的对象)。

但是，在参数输入方面，我不太清楚。我可以拿IEnumerable , 但如果我需要多次枚举怎么办？

俗话说“对发送的内容要保守，对接受的内容要自由”建议采取 IEnumerable很好，但我不太确定。

例如，如果以下IEnumerable中没有元素参数，通过检查 .Any() 可以在此方法中节省大量工作首先，这需要 ToList()在此之前避免枚举两次。

public IEnumerable<Data> RemoveHandledForDate(IEnumerable<Data> data, DateTime dateTime) {
   var dataList = data.ToList();

   if (!dataList.Any()) {
      return dataList;
   }

   var handledDataIds = new HashSet<int>(
      GetHandledDataForDate(dateTime) // Expensive database operation
         .Select(d => d.DataId)
   );

   return dataList.Where(d => !handledDataIds.Contains(d.DataId));
}

所以我想知道最好的签名是什么？一种可能性是 IList<Data> data , 但接受一个列表表明你打算修改它，这是不正确的——这个方法没有触及原始列表，所以 IReadOnlyCollection<Data>看起来好多了。

但是IReadOnlyCollection强制调用者做 ToList().AsReadOnly()每次都变得有点难看，即使使用自定义扩展方法也是如此 .AsReadOnlyCollection .这在所接受的方面并不自由。

这种情况下的最佳做法是什么？

此方法不返回 IReadOnlyCollection因为最后的 Where 可能有值(value)使用延迟执行，因为不需要 枚举整个列表。然而，Select需要枚举，因为做 .Contains 的成本没有 HashSet 会很糟糕.

我调用 ToList 没问题，我突然想到，如果我需要 List为了避免多重枚举，为什么我不在参数中只要求一个？所以这里的问题是，如果我不想要 IEnumerable在我的方法中，我是否真的应该接受一个以变得自由(和 ToList 我自己)，或者我应该把负担放在调用者身上 ToList().AsReadOnly() ？

为不熟悉 IEnumerables 的人提供的更多信息

这里真正的问题不是 Any() 的成本与 ToList() .我知道枚举整个列表比做 Any() 花费更多.但是，假设调用者将消耗返回中的所有项目 IEnumerable从上面的方法，并假设来源IEnumerable<Data> data参数来自此方法的结果:

public IEnumerable<Data> GetVeryExpensiveDataForDate(DateTime dateTime) {
    // This query is very expensive no matter how many rows are returned.
    // It costs 5 seconds on each `.GetEnumerator` call to get 1 value or 1000
    return MyDataProvider.Where(d => d.DataDate == dateTime);
}

现在如果你这样做:

var myData = GetVeryExpensiveDataForDate(todayDate);
var unhandledData = RemoveHandledForDate(myData, todayDate);
foreach (var data in unhandledData) {
   messageBus.Dispatch(data); // fully enumerate
)

如果RemovedHandledForDate做 Any 和做Where ，您将承担 5 秒的费用两次，而不是一次。这就是为什么您应该始终竭尽全力避免枚举 IEnumerable不止一次。不要相信它实际上是无害的知识，因为 future 某个倒霉的开发人员可能有一天会用新实现的 IEnumerable 调用您的方法。你想不到的，它有不同的特点。

IEnumerable 的契约(Contract)说你可以枚举它。它不 promise 多次这样做的性能特征。

事实上，一些IEnumerables volatile 并且不会在后续枚举时返回任何数据!如果与多重枚举相结合，切换到一个将是一个完全破坏性的变化(如果稍后添加多重枚举，则很难诊断)。

不要对 IEnumerable 进行多次枚举。

如果您接受一个 IEnumerable 参数，您实际上是在 promise 将它精确枚举 0 次或 1 次。

最佳答案

IReadOnlyCollection<T>添加到 IEnumerable<T>一个Count属性(property)和相应的 promise ，即没有延迟执行。如果该参数是您想要解决此问题的地方，这将是要求的适当参数。

但是，我建议询问 IEnumerable<T> , 并调用 ToList()而不是在实现本身中。

观察:这两种方法都有一个缺点，即多重枚举可能在某些时候被重构掉，呈现参数变化或 ToList()称为冗余，我们可能会忽略这一点。我认为这是无法避免的。

这个案例确实可以调用ToList()在方法体中:由于多重枚举是一个实现细节，因此避免它也应该是一个实现细节。这样，我们就避免了影响 API。如果多重枚举被重构掉，我们也避免更改回 API。我们还避免通过一系列方法传播需求，所有这些方法都必须请求 IReadOnlyCollection<T>。只是因为我们的多重枚举。

如果您担心创建额外列表的开销(当输出已经是一个列表左右时)，Resharper 建议采用以下方法:

param = param as IList<SomeType> ?? param.ToList();

当然，我们可以做得更好，因为我们只需要防止延迟执行 - 不需要成熟的 IList<T> :

param = param as IReadOnlyCollection<SomeType> ?? param.ToList();

关于c# - 参数 : IEnumerable vs. IList 与 IReadOnlyCollection 的最佳实践，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33637294/