从只能迭代一次的 IEnumerable 获取头和尾

Question

我有一系列元素。该序列只能迭代一次并且可以是“无限”的。

获取此类序列的头部和尾部的最佳方法是什么？

更新：如果我将其包含在原始问题中，那就太好了:)

• Head 是序列的第一个元素，tail 是“其余的”。这意味着尾巴也是“无限”的。

• 当我说无限时，我的意思是“非常大”和“我不想一次将其全部存储在内存中”。它实际上也可能是无限的，例如传感器数据（但在我的情况下不是）。

• 当我说它只能迭代一次时，我的意思是生成序列需要大量资源，所以我不想再这样做。它也可能是易失性数据，再次像传感器数据一样，在下次读取时不会相同（但在我的情况下不是）。

Answer 1

将 IEnumerable 分解为 head & tail 对于递归处理来说并不是特别好（与函数列表不同），因为当您递归地使用 tail 操作时，您将创建许多间接寻址。但是，您可以编写如下内容：

我忽略了参数检查和异常处理等内容，但它显示了这个想法...

Tuple<T, IEnumerable<T>> HeadAndTail<T>(IEnumerable<T> source) {
  // Get first element of the 'source' (assuming it is there)
  var en = source.GetEnumerator();
  en.MoveNext();
  // Return first element and Enumerable that iterates over the rest
  return Tuple.Create(en.Current, EnumerateTail(en));
}

// Turn remaining (unconsumed) elements of enumerator into enumerable
IEnumerable<T> EnumerateTail<T>(IEnumerator en) {
  while(en.MoveNext()) yield return en.Current; 
}

HeadAndTail 方法获取第一个元素并将其作为第一个元素返回元组的。元组的第二个元素是 IEnumerable，它是从剩余元素生成的（通过迭代我们已经创建的枚举器的其余部分）。

Answer 2

显然，每次调用 HeadAndTail 都应该再次枚举序列（除非使用某种缓存）。例如，请考虑以下情况：

var a = HeadAndTail(sequence);
Console.WriteLine(HeadAndTail(a.Tail).Tail);
//Element #2; enumerator is at least at #2 now.

var b = HeadAndTail(sequence);
Console.WriteLine(b.Tail);
//Element #1; there is no way to get #1 unless we enumerate the sequence again.

出于同样的原因，HeadAndTail 无法实现为单独的 Head 和 Tail 方法（除非您甚至想要首先调用 Tail 再次枚举序列，即使它已经通过调用 Head 枚举过）。

此外，HeadAndTail 不应返回 IEnumerable 的实例（因为它可能会被枚举多次）。

这给我们留下了唯一的选择：HeadAndTail应该返回IEnumerator，并且，为了让事情变得更明显，它也应该接受IEnumerator（我们只是将 GetEnumerator 的调用从 HeadAndTail 内部移动到外部，以强调它仅供一次性使用）。

现在我们已经解决了需求，实现就非常简单了：

class HeadAndTail<T> {
    public readonly T Head;
    public readonly IEnumerator<T> Tail;

    public HeadAndTail(T head, IEnumerator<T> tail) {
        Head = head;
        Tail = tail;
    }
}

static class IEnumeratorExtensions {
    public static HeadAndTail<T> HeadAndTail<T>(this IEnumerator<T> enumerator) {
        if (!enumerator.MoveNext()) return null;
        return new HeadAndTail<T>(enumerator.Current, enumerator);
    }
}

现在它可以像这样使用：

Console.WriteLine(sequence.GetEnumerator().HeadAndTail().Tail.HeadAndTail().Head);
//Element #2

或者在像这样的递归函数中：

TResult FoldR<TSource, TResult>(
    IEnumerator<TSource> sequence,
    TResult seed,
    Func<TSource, TResult, TResult> f
) {
    var headAndTail = sequence.HeadAndTail();
    if (headAndTail == null) return seed;
    return f(headAndTail.Head, FoldR(headAndTail.Tail, seed, f));
}

int Sum(IEnumerator<int> sequence) {
    return FoldR(sequence, 0, (x, y) => x+y);
}

var array = Enumerable.Range(1, 5);
Console.WriteLine(Sum(array.GetEnumerator())); //1+(2+(3+(4+(5+0)))))

Answer 3

虽然此处的其他方法建议对 tail 枚举使用 yield return，但这种方法会增加不必要的嵌套开销。更好的方法是将 Enumerator 转换回可以与 foreach 一起使用的东西：

public struct WrappedEnumerator<T>
{
    T myEnumerator;
    public T GetEnumerator() { return myEnumerator; }
    public WrappedEnumerator(T theEnumerator) { myEnumerator = theEnumerator; }
}
public static class AsForEachHelper
{
    static public WrappedEnumerator<IEnumerator<T>> AsForEach<T>(this IEnumerator<T> theEnumerator) {return new WrappedEnumerator<IEnumerator<T>>(theEnumerator);}

    static public WrappedEnumerator<System.Collections.IEnumerator> AsForEach(this System.Collections.IEnumerator theEnumerator) 
        { return new WrappedEnumerator<System.Collections.IEnumerator>(theEnumerator); }
}

如果使用单独的 WrappedEnumerator 结构通用 IEnumerable 和非通用 IEnumerable，可以让它们实现 IEnumerable 和 IEnumerable > 分别；不过，他们不会真正遵守 IEnumerable 约定，该约定指定应该可以多次调用 GetEnumerator()，并且每次调用都会返回一个独立的枚举器。

另一个重要的警告是，如果在 IEnumerator 上使用 AsForEach，则应准确枚举生成的 WrappedEnumerator。 > 一次。如果从未枚举它，则底层 IEnumerator 将永远不会调用其 Dispose 方法。

将上面提供的方法应用于当前的问题，可以轻松地在 IEnumerable 上调用 GetEnumerator()，读出前几项，然后然后使用 AsForEach() 转换余数，以便可以将其与 ForEach 循环一起使用（或者，如上所述，将其转换为 的实现） IEnumerable）。但值得注意的是，调用 GetEnumerator() 会产生 Dispose 生成的 IEnumerator 的义务，以及执行该操作的类如果没有任何东西在尾部调用 GetEnumerator() ，那么头/尾分割将无法做到这一点。

Answer 4

可能不是最好的方法，但如果您使用 .ToList() 方法，您可以获取位置 [0] 和 [Count- 1]，如果计数> 0.

但是您应该指定“只能迭代一次”是什么意思

Answer 5

.First() 和 .Last() 到底有什么问题？虽然是的，我必须同意那些问“无限列表的尾部意味着什么”的人......这个概念没有意义，IMO。