处理 IEnumerable 可能的多重枚举的警告

Question

在我的代码中，我需要多次使用 IEnumerable<>，导致 ReSharper 错误“IEnumerable 的可能多重枚举”。

示例代码：

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null || !objects.Any())
        throw new ArgumentException();
        
    var firstObject = objects.First();
    var list = DoSomeThing(firstObject);        
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);
    
    return list;
}

• 我可以将objects 参数更改为List，然后避免可能的多重枚举，但是我没有得到我可以处理的最高对象。
• 我可以做的另一件事是将方法开头的IEnumerable 转换为List：

---

 public List<object> Foo(IEnumerable<object> objects)
 {
    var objectList = objects.ToList();
    // ...
 }

但这只是尴尬。

在这种情况下你会怎么做？

Answer 1

将IEnumerable 作为参数的问题在于它告诉调用者“我希望枚举这个”。它没有告诉他们您希望枚举多少次。

我可以将 objects 参数更改为 List，然后避免可能的多重枚举，但是我没有得到 我可以处理的最高对象。

取最高物的目标是崇高的，但它为太多的假设留下了空间。您是否真的希望有人将 LINQ to SQL 查询传递给此方法，只是让您枚举它两次（每次都可能得到不同的结果？）

这里缺少的语义是调用者可能不花时间阅读方法的细节，可能会假设您只迭代一次 - 所以他们传递给您一个昂贵的对象。您的方法签名并不表示任何一种方式。

通过将方法签名更改为IList/ICollection，您至少可以让调用者更清楚您的期望是什么，并且他们可以避免代价高昂的错误。

否则，大多数研究该方法的开发人员可能会认为您只迭代一次。如果采取IEnumerable 如此重要，您应该考虑在方法开始时执行.ToList()。

很遗憾 .NET 没有 IEnumerable + Count + Indexer 的接口，没有添加/删除等方法，我怀疑这是可以解决这个问题的方法。

Answer 2

如果您的数据总是可重复的，也许不用担心。但是，您也可以展开它 - 如果传入的数据可能很大（例如，从磁盘/网络读取），这尤其有用：

if(objects == null) throw new ArgumentException();
using(var iter = objects.GetEnumerator()) {
    if(!iter.MoveNext()) throw new ArgumentException();

    var firstObject = iter.Current;
    var list = DoSomeThing(firstObject);  

    while(iter.MoveNext()) {
        list.Add(DoSomeThingElse(iter.Current));
    }
    return list;
}

注意我稍微改变了 DoSomethingElse 的语义，但这主要是为了展示展开的用法。例如，您可以重新包装迭代器。你也可以把它变成一个迭代器块，这很好；那么就没有list - 你会在获得项目时yield return，而不是添加到要返回的列表中。

Answer 3

首先，该警告并不总是那么重要。我通常在确保它不是性能瓶颈后禁用它。这只是意味着IEnumerable 被评估了两次，这通常不是问题，除非evaluation 本身需要很长时间。即使确实需要很长时间，在这种情况下，您第一次只使用一个元素。

在这种情况下，您还可以进一步利用强大的 linq 扩展方法。

var firstObject = objects.First();
return DoSomeThing(firstObject).Concat(DoSomeThingElse(objects).ToList();

在这种情况下，可能只评估一次IEnumerable 会有些麻烦，但请先进行分析，看看它是否真的有问题。

Answer 4

如果目标确实是为了防止多次枚举，而不是 Marc Gravell 的答案是要阅读的答案，但保持相同的语义，您可以简单地删除多余的 Any 和 First 调用并继续：

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null)
        throw new ArgumentNullException("objects");

    var first = objects.FirstOrDefault();

    if (first == null)
        throw new ArgumentException(
            "Empty enumerable not supported.", 
            "objects");

    var list = DoSomeThing(first);  

    var secondList = DoSomeThingElse(objects);

    list.AddRange(secondList);

    return list;
}

请注意，这假定您 IEnumerable 不是通用的，或者至少被限制为引用类型。

Answer 5

在这种情况下，我通常使用 IEnumerable 和 IList 重载我的方法。

public static IEnumerable<T> Method<T>( this IList<T> source ){... }

public static IEnumerable<T> Method<T>( this IEnumerable<T> source )
{
    /*input checks on source parameter here*/
    return Method( source.ToList() );
}

我注意在摘要中解释调用 IEnumerable 将执行 .ToList() 的方法。

如果要连接多个操作，程序员可以选择更高级别的 .ToList()，然后调用 IList 重载或让我的 IEnumerable 重载来处理。

Answer 6

在方法签名中使用IReadOnlyCollection<T> 或IReadOnlyList<T> 代替IEnumerable<T> 的优点是明确表示您可能需要在迭代之前检查计数，或者出于某些其他原因进行多次迭代。

但是，它们有一个巨大的缺点，如果您尝试重构代码以使用接口，例如使其更可测试且对动态代理更友好，则会导致问题。关键是 IList<T> 不继承自 IReadOnlyList<T>，对于其他集合及其各自的只读接口也是如此。 （简而言之，这是因为 .NET 4.5 想要保持 ABI 与早期版本的兼容性。But they didn't even take the opportunity to change that in .NET core.）

这意味着，如果您从程序的某个部分获得IList<T>，并希望将其传递给期望IReadOnlyList<T> 的另一部分，则不能！ 您可以将IList<T> 作为IEnumerable<T> 传递。

最后，IEnumerable<T> 是所有 .NET 集合（包括所有集合接口）都支持的唯一只读接口。当您意识到您将自己锁定在某些架构选择之外时，任何其他选择都会回来咬您。所以我认为在函数签名中使用它来表达你只想要一个只读集合是正确的类型。

（请注意，如果底层类型支持这两个接口，您始终可以编写一个简单转换的 IReadOnlyList<T> ToReadOnly<T>(this IList<T> list) 扩展方法，但在重构时您必须在任何地方手动添加它，因为 IEnumerable<T> 始终兼容。）

与往常一样，这不是绝对的，如果您正在编写大量数据库的代码，而意外的多次枚举将是一场灾难，您可能更喜欢不同的权衡。

Answer 7

如果您只需要检查第一个元素，则无需遍历整个集合即可查看它：

public List<object> Foo(IEnumerable<object> objects)
{
    object firstObject;
    if (objects == null || !TryPeek(ref objects, out firstObject))
        throw new ArgumentException();

    var list = DoSomeThing(firstObject);
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}

public static bool TryPeek<T>(ref IEnumerable<T> source, out T first)
{
    if (source == null)
        throw new ArgumentNullException(nameof(source));

    IEnumerator<T> enumerator = source.GetEnumerator();
    if (!enumerator.MoveNext())
    {
        first = default(T);
        source = Enumerable.Empty<T>();
        return false;
    }

    first = enumerator.Current;
    T firstElement = first;
    source = Iterate();
    return true;

    IEnumerable<T> Iterate()
    {
        yield return firstElement;
        using (enumerator)
        {
            while (enumerator.MoveNext())
            {
                yield return enumerator.Current;
            }
        }
    }
}

Answer 8

如果他们可能需要多次枚举事物，我喜欢采用 IReadOnlyCollection 的方法。我想提供一个实用方法，可以在将 IEnumerable 转换为 IReadOnlyCollection 时调用该方法。与 ToArray() 或 ToList() 不同，它可以避免额外分配改变底层集合类型的成本：

    public static class EnumerableUtils
    {
        /* Ensures an IEnumerable is only enumerated once  */
        public static IReadOnlyCollection<T> AsEnumerated<T>(this IEnumerable<T> original)
        {
            if (original is IReadOnlyCollection<T> originalCollection)
            {
                return originalCollection;
            }

            return ImmutableArray.CreateRange(original);
        }
    }

Answer 9

使用 .NET 6/C# 10

.. 及以上您可以尝试使用Enumerable.TryGetNonEnumeratedCount(IEnumerable, Int32) 方法确定序列中元素的数量，而无需强制枚举。

如果不用枚举就能确定source的计数，该方法返回true；否则，false。因此，您可以检查是否需要进一步实施。

using System;
using System.Collections.Generic;
using System.Linq;
                    
public class Program
{
    public static void Main()
    {
        IEnumerable<int> arrayOne = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        var canGetCountDirectly = arrayOne.TryGetNonEnumeratedCount(out int theCount);

        Console.WriteLine($"Count can be returned directly = {canGetCountDirectly}");
        Console.WriteLine($"Count = {theCount}");
    }
}