Quand dois-je utiliser IEnumerator pour faire des boucles en c#?

Je me demandais s'il y a des fois où il est avantageux d'utiliser un IEnumerator sur une boucle foreach pour parcourir en une collection? Par exemple, est-il un moment où il serait préférable d'utiliser des exemples de code suivants sur les autres?

IEnumerator<MyClass> classesEnum = myClasses.GetEnumerator();
while(classesEnum.MoveNext())
    Console.WriteLine(classesEnum.Current);

au lieu de 

foreach (var class in myClasses)
    Console.WriteLine(class);
InformationsquelleAutor lomaxx | 2009-01-19
  1. 31

    Tout d'abord, notez qu'une grande différence dans votre exemple (entre foreach et GetEnumerator), c'est que foreach garanties pour appeler Dispose() sur l'itérateur si l'itérateur est IDisposable. C'est important pour beaucoup d'itérateurs (qui pourrait être de consommer une alimentation de données externes, par exemple).

    En fait, il y a des cas où foreach n'est pas aussi utiles que nous le souhaiterions.

    Tout d'abord, il est le "premier élément" cas discuté ici (foreach /détection de la première itération).

    Mais plus; si vous essayez d'écrire le manque Zip méthode pour la couture de deux énumérable les séquences (ou le SequenceEqual méthode), vous trouverez que vous pouvez utiliser foreach sur les deux séquences, car ce serait d'effectuer un cross-jointure. Vous devez utiliser l'itérateur directement pour l'un d'entre eux:

    static IEnumerable<T> Zip<T>(this IEnumerable<T> left,
    IEnumerable<T> right)
{
    using (var iter = right.GetEnumerator())
    {
        //consume everything in the first sequence
        foreach (var item in left)
        {
            yield return item;

            //and add an item from the second sequnce each time (if we can)
            if (iter.MoveNext())
            {
                yield return iter.Current;
            }
        }
        //any remaining items in the second sequence
        while (iter.MoveNext())
        {
            yield return iter.Current;
        }                
    }            
}

static bool SequenceEqual<T>(this IEnumerable<T> left,
    IEnumerable<T> right)
{
    var comparer = EqualityComparer<T>.Default;

    using (var iter = right.GetEnumerator())
    {
        foreach (var item in left)
        {
            if (!iter.MoveNext()) return false; //first is longer
            if (!comparer.Equals(item, iter.Current))
                return false; //item different
        }
        if (iter.MoveNext()) return false; //second is longer
    }
    return true; //same length, all equal            
}
    • Ne devrait-il pas être quelque chose comme while(iter.MoveNext()) dans le cas où le droit a deux ou plus de deux éléments de gauche?
    • Salut Marc, très bonne réponse! Allez-vous élaborer sur ce que vous voulez dire par "l'exécution d'une croix-joignez-vous"?
    • je suis peut-être abuser de SQL terminologie, mais par une croix-rejoindre je voulais simplement dire que le produit cartésien entre les deux ensembles
    • Merci pour les précisions!
    InformationsquelleAutor Marc Gravell
  2. 19

    Selon la Langage C# spec:

    Une instruction foreach de la forme

    foreach (V v in x) embedded-statement

    est ensuite étendu à:

    {
    E e = ((C)(x)).GetEnumerator();
    try {
            V v;
            while (e.MoveNext()) {
                    v = (V)(T)e.Current;
                    embedded-statement
            }
    }
    finally {
            ... //Dispose e
    }
}

    L'essence de vos deux exemples sont les mêmes, mais il ya quelques différences importantes, notamment la try/finally.

    • Intéressant car cela montre aussi ce genre de conversions implicites (en option défini par l'Utilisateur) peut être déclenché
    InformationsquelleAutor Jay Bazuzi
  3. 12

    En C#, foreach est en train de faire exactement la même chose que le IEnumerator code que vous avez posté ci-dessus. Le foreach construction est prévue pour le rendre plus facile pour le programmeur. Je crois qu'IL a généré dans les deux cas est le même.

    • Il ya des cas où vous avez besoin de le faire manuellement, voir ma réponse ci-dessous.
    • En fait, non, IL est pas, identique dans son échantillon, parce qu'il n'a pas vérifié l'itérateur pour IDisposable. C'est important pour beaucoup d'itérateurs.
    InformationsquelleAutor Andy
  4. 4

    Je l'ai utilisé parfois lors de la première itération de faire quelque chose de différent des autres.

    Par exemple, si vous souhaitez imprimer les membres de la console et des résultats séparés par la ligne, que vous pouvez écrire.

    using (IEnumerator<MyClass> classesEnum = myClasses.GetEnumerator()) {
    if (classEnum.MoveNext())
        Console.WriteLine(classesEnum.Current);
    while (classesEnum.MoveNext()) {
        Console.WriteLine("-----------------");
        Console.WriteLine(classesEnum.Current);
    }
}

    Alors le résultat est

    myClass 1
-----------------
myClass 2
-----------------
myClass 3

    Et dans une autre situation, c'est quand je itération 2 agents recenseurs ensemble.

    using (IEnumerator<MyClass> classesEnum = myClasses.GetEnumerator()) {
    using (IEnumerator<MyClass> classesEnum2 = myClasses2.GetEnumerator()) {
        while (classesEnum.MoveNext() && classEnum2.MoveNext())
            Console.WriteLine("{0}, {1}", classesEnum.Current, classesEnum2.Current);
    }
}

    résultat

    myClass 1, myClass A
myClass 2, myClass B
myClass 3, myClass C

    À l'aide de agent recenseur vous permet de ne plus flexible sur vos itération. Mais dans la plupart des cas, vous pouvez utiliser foreach

    InformationsquelleAutor Chaowlert Chaisrichalermpol