安全检查不可重复的 IEnumerables 是否为空

Question

有时检查不可重复 IEnumerable 来查看它是否为空会很有帮助。 LINQ 的 Any 对此效果不佳，因为它消耗了序列的第一个元素，例如

if(input.Any())
{
    foreach(int i in input)
    {
        // Will miss the first element for non-repeatable sequences!
    }
}

（注意：我知道在这种情况下不需要进行检查 - 它只是一个现实世界的示例是对可能为空的右侧 IEnumerable 执行 Zip，如果它是空的，我希望结果是左侧的。手IEnumerable 按原样。）

我想出了一个可能的解决方案，如下所示：

private static IEnumerable<T> NullifyIfEmptyHelper<T>(IEnumerator<T> e)
{
    using(e)
    {
        do
        {
            yield return e.Current;
        } while (e.MoveNext());
    }
}

public static IEnumerable<T> NullifyIfEmpty<T>(this IEnumerable<T> source)
{
    IEnumerator<T> e = source.GetEnumerator();
    if(e.MoveNext())
    {
        return NullifyIfEmptyHelper(e);
    }
    else
    {
        e.Dispose();
        return null;
    }
}

然后可以按如下方式使用：

input = input.NullifyIfEmpty();
if(input != null)
{
    foreach(int i in input)
    {
        // Will include the first element.
    }
}

我对此有两个问题：

1）这是合理的事情吗？做？从性能的角度来看，这可能存在问题吗？ （我猜不会，但值得一问。）

2）是否有更好的方法来实现相同的最终目标？

---

编辑＃1：

这是一个不可重复的 IEnumerable 的示例，以澄清：

private static IEnumerable<int> ReadNumbers()
{
    for(;;)
    {
        int i;
        if (int.TryParse(Console.ReadLine(), out i) && i != -1)
        {
            yield return i;
        }
        else
        {
            yield break;
        }
    }
}

基本上，来自用户输入或流等的东西。

编辑＃2：

我需要澄清我是寻找一种保留 IEnumerable 的惰性本质的解决方案 - 在某些情况下将其转换为列表或数组可能是一个答案，但这不是我想要的米之后 这里。 （现实世界的原因是，在我的例子中，IEnumerable 中的项目数量可能很大，重要的是不要将它们一次全部存储在内存中。）

Answer 1

您也可以只读取第一个元素，如果它不为空，则将第一个元素与输入的其余部分连接起来：

var input = ReadNumbers();
var first = input.FirstOrDefault();
if (first != default(int)) //Assumes input doesn't contain zeroes
{
    var firstAsArray = new[] {first};
    foreach (int i in firstAsArray.Concat(input))
    {
        // Will include the first element.
        Console.WriteLine(i);
    }
}

对于正常的可枚举，第一个元素将重复两次，但对于不可重复的可枚举，它将起作用，除非不允许迭代两次。另外，如果您有这样的枚举器：

private readonly static List<int?> Source = new List<int?>(){1,2,3,4,5,6};

private static IEnumerable<int?> ReadNumbers()
{
    while (Source.Count > 0) {
        yield return Source.ElementAt(0);
        Source.RemoveAt(0);
    }
}

那么它将打印： 1, 1, 2, 3, 4, 5, 6。原因是第一个元素在返回后被消耗。因此，第一个枚举器在第一个元素处停止，永远没有机会消耗该第一个元素。但这将是一个写得很糟糕的枚举器的情况。如果元素被消耗，则返回...

while (Source.Count > 0) {
    var returnElement = Source.ElementAt(0);
    Source.RemoveAt(0);
    yield return returnElement;
}

...您将得到预期输出：1,2,3,4,5,6。

Answer 2

你不需要把它复杂化。带有一个额外的 bool 变量的常规 foreach 循环就可以解决问题。

如果您

if(input.Any())
{
    A
    foreach(int i in input)
    {
        B
    }
    C
}

不想读取 input 两次，则可以将其更改为

bool seenItem = false;
foreach(int i in input)
{
    if (!seenItem)
    {
        seenItem = true;
        A
    }
    B
}
if (seenItem)
{
    C
}

根据 B 的操作，您也许能够避免 seenItem完全变量。

就您而言，Enumerable.Zip 是一个相当基本的函数，很容易重新实现，并且您的替换函数可以使用与上面类似的函数。

编辑：您可能会考虑

public static class MyEnumerableExtensions
{
    public static IEnumerable<TFirst> NotReallyZip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TFirst> resultSelector)
    {
        using (var firstEnumerator = first.GetEnumerator())
        using (var secondEnumerator = second.GetEnumerator())
        {
            if (secondEnumerator.MoveNext())
            {
                if (firstEnumerator.MoveNext())
                {
                    do yield return resultSelector(firstEnumerator.Current, secondEnumerator.Current);
                    while (firstEnumerator.MoveNext() && secondEnumerator.MoveNext());
                }
            }
            else
            {
                while (firstEnumerator.MoveNext())
                    yield return firstEnumerator.Current;
            }
        }
    }
}

Answer 3

如果枚举很长，这不是一个有效的解决方案，但它是一个简单的解决方案：

var list = input.ToList();
if (list.Count != 0) {
    foreach (var item in list) {
       ...
    }
}