是否有一个IEnumerator一个“HasNext”的方法？

Question

使用的Java Iterators，我已经使用了hasNext方法来确定迭代是否具有多个元素（而不消耗的元素） - 。因此，hasNext是像一个“Peek”方法

我的问题：是否有像 “hasNext” 或与C＃的通用Peeks “IEnumerator” 方法的任何

？

Answer 1

没有，不幸的是没有。

在 IEnumerator<T> 的接口只公开以下成员：

<强>方法：

  

Dispose结果    MoveNext结果    Reset

<强>属性：

  

Current

Answer 2

没有，但在C＃中，你可以反复询问当前元素没有移动到下一个。这是看它只是用不同的方式。

这不会是的太的难写C＃类采取了.NET样式IEnumerator并返回一个Java风格Iterator。我个人觉得在.NET的风格更容易在大多数情况下使用，但我们去：）

编辑：好的，这是完全未经测试，但我的认为的它会奏效。它至少编译：）

using System;
using System.Collections;
using System.Collections.Generic;

// // Mimics Java's Iterable<T> interface
public interface IIterable<T>
{
    IIterator<T> Iterator();
}

// Mimics Java's Iterator interface - but
// implements IDisposable for the sake of
// parity with IEnumerator.
public interface IIterator<T> : IDisposable
{
    bool HasNext { get; }
    T Next();
    void Remove();
}

public sealed class EnumerableAdapter<T> : IIterable<T>
{
    private readonly IEnumerable<T> enumerable;

    public EnumerableAdapter(IEnumerable<T> enumerable)
    {
        this.enumerable = enumerable;
    }

    public IIterator<T> Iterator()
    {
        return new EnumeratorAdapter<T>(enumerable.GetEnumerator());
    }
}

public sealed class EnumeratorAdapter<T> : IIterator<T>
{
    private readonly IEnumerator<T> enumerator;

    private bool fetchedNext = false;
    private bool nextAvailable = false;
    private T next;

    public EnumeratorAdapter(IEnumerator<T> enumerator)
    {
        this.enumerator = enumerator;
    }

    public bool HasNext
    {
        get
        {
            CheckNext();
            return nextAvailable;
        } 
    }

    public T Next()
    {
        CheckNext();
        if (!nextAvailable)
        {
            throw new InvalidOperationException();
        }
        fetchedNext = false; // We've consumed this now
        return next;
    }

    void CheckNext()
    {
        if (!fetchedNext)
        {
            nextAvailable = enumerator.MoveNext();
            if (nextAvailable)
            {
                next = enumerator.Current;
            }
            fetchedNext = true;            
        }
    }

    public void Remove()
    {
        throw new NotSupportedException();
    }

    public void Dispose()
    {
        enumerator.Dispose();
    }
}

public sealed class IterableAdapter<T> : IEnumerable<T>
{
    private readonly IIterable<T> iterable;

    public IterableAdapter(IIterable<T> iterable)
    {
        this.iterable = iterable;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new IteratorAdapter<T>(iterable.Iterator());
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public sealed class IteratorAdapter<T> : IEnumerator<T>
{
    private readonly IIterator<T> iterator;

    private bool gotCurrent = false;
    private T current;

    public IteratorAdapter(IIterator<T> iterator)
    {
        this.iterator = iterator;
    }

    public T Current
    {
        get
        {
            if (!gotCurrent)
            {
                throw new InvalidOperationException();
            }
            return current;
        }
    }

    object IEnumerator.Current
    {
        get { return Current; }
    }

    public bool MoveNext()
    {
        gotCurrent = iterator.HasNext;
        if (gotCurrent)
        {
            current = iterator.Next();
        }
        return gotCurrent;
    }

    public void Reset()
    {
        throw new NotSupportedException();
    }

    public void Dispose()
    {
        iterator.Dispose();
    }
}

Answer 3

枚举常常懒惰地评估如此HasNext没有什么意义。

Answer 4

都能跟得上时，只是MoveNext，Reset和Current。

Answer 5

您也可以尝试在看看这个实施皮克到的IEnumerator和IEnumerator的<> 。那就是增加了窥视功能IEnumerator的扩展方法。希望能帮助到你。 ：）