Est-il un “HasNext” la méthode pour une IEnumerator?

Avec Java Iterators, j'ai utilisé le hasNext méthode pour déterminer si une itération plus d'éléments (sans consommation d'un élément) -- ainsi, hasNext est comme un "Peek" la méthode.

Ma question: est-il quelque chose comme un "hasNext" ou "Peek" avec C#'s générique IEnumerators?

Comment pourriez-vous éventuellement ne pas savoir? Est-il possible que vous ne l'avez jamais vu msdn.microsoft.com/en-us/library/78dfe2yb.aspx?
Merci beaucoup pour souligner ce point, M. Saunders.

OriginalL'auteur JaysonFix | 2009-08-13

  1. 17

    Non, malheureusement il n'y en a pas.

    La IEnumerator<T> interface seulement expose les membres suivants:

    Méthodes:

    Dispose

    MoveNext

    Reset

    Propriétés:

    Current

    Merci, Andrew.
    Nous prenons sur IEnumerator, au lieu de IEnumerable ici, non? Et * devrait être sur de Disposer, au lieu de MoveNext.
    Aïe, ce poste a été en proie à des erreurs! Merci pour le tuyau.

    OriginalL'auteur Andrew Hare

  2. 34

    Pas, mais en C#, vous pouvez demander à plusieurs reprises pour l'élément courant, sans procéder à la suivante. C'est juste une façon différente de voir les choses.

    Il ne serait pas trop difficile d'écrire une classe C# pour prendre un .NET-style IEnumerator et retourner un Java-style Iterator. Personnellement, je trouve la .Style NET plus facile à utiliser dans la plupart des cas, mais nous y voilà 🙂

    EDIT: Bon, ce n'est absolument pas testé, mais je pense il va travailler. Elle permet au moins de compiler 🙂

    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();
}
}
    +1 C'est vraiment juste prendre un différent sur le même modèle.
    (Je suis heureux de code de l'adaptateur si ça intéresse quelqu'un, mais je ne vais pas faire autrement...)
    Je serais curieux de voir ça, Jon.
    Wow, c'était rapide! Merci à vous, Jon!
    elle place la responsabilité d'un peu différent. Je trouve le dotNet version plus facile de travailler avec.

    OriginalL'auteur Jon Skeet

  3. 3

    Agents recenseurs sont souvent paresseusement évalués, de façon à HasNext peu de sens.

    OriginalL'auteur Ray

  4. 2

    Nope, juste MoveNext, Reset et Current.

    OriginalL'auteur Matt Howells

  5. 2

    Vous pouvez également essayer d'avoir un coup d'oeil à ce La mise en œuvre d'Œil à IEnumerator et IEnumerator<>. C'est une méthode d'extension qui ajoute de l'Œil de la fonctionnalité IEnumerator. Espérons que cela aide. 🙂

    OriginalL'auteur Bryida