IEnumerable, IEnumerator vs foreach, quand utiliser

Question

Je passais par IEnumerable et IEnumerator, mais je ne pouvais pas obtenir un point clairement .. si nous avons foreach, alors pourquoi avons-nous besoin de ces deux interfaces? Y at-il un scénario où nous devons utiliser des interfaces. Si oui, alors quelqu'un peut-il expliquer avec un exemple. Toutes les suggestions et remarques sont les bienvenues. Merci.

Answer 1

foreachutilise les interfaces dans de nombreux cas. Vous avez besoin des interfaces si vous voulez mettre en œuvre une séquence que foreach peut alors utiliser. (Les blocs d'itérateur rendent généralement cette tâche d'implémentation très simple cependant.)

Cependant, juste parfois il peut être utile d'utiliser directement les itérateurs. Un bon exemple est lorsque vous essayez de «jumeler» deux séquences différentes. Par exemple, supposons que vous receviez deux séquences - l'une de noms, l'une d'âges, et que vous voulez imprimer les deux ensemble. Vous pouvez écrire:

static void PrintNamesAndAges(IEnumerable<string> names, IEnumerable<int> ages) 
{ 
    using (IEnumerator<int> ageIterator = ages.GetEnumerator()) 
    { 
     foreach (string name in names) 
     { 
      if (!ageIterator.MoveNext()) 
      { 
       throw new ArgumentException("Not enough ages"); 
      } 
      Console.WriteLine("{0} is {1} years old", name, ageIterator.Current); 
     } 
     if (ageIterator.MoveNext()) 
     { 
      throw new ArgumentException("Not enough names"); 
     } 

    } 
} 

De même, il peut être utile d'utiliser l'itérateur si vous voulez traiter (par exemple) le premier élément différemment du reste:

public T Max<T>(IEnumerable<T> items) 
{ 
    Comparer<T> comparer = Comparer<T>.Default; 

    using (IEnumerator<T> iterator = items.GetEnumerator()) 
    { 
     if (!iterator.MoveNext()) 
     { 
      throw new InvalidOperationException("No elements"); 
     } 
     T currentMax = iterator.Current; 

     // Now we've got an initial value, loop over the rest 
     while (iterator.MoveNext()) 
     { 
      T candidate = iterator.Current; 
      if (comparer.Compare(candidate, currentMax) > 0) 
      { 
       currentMax = candidate; 
      } 
     } 
     return currentMax; 
    } 
} 

---

Maintenant, si vous Vous êtes intéressé par la différence entre IEnumerator<T> et IEnumerable<T>, vous pourriez vouloir penser à cela en termes de base de données: pensez à IEnumerable<T> en tant que table, et IEnumerator<T> en tant que curseur. Vous pouvez demander à une table de vous donner un nouveau curseur, et vous pouvez avoir plusieurs curseurs sur la même table en même temps.

Cela peut prendre un certain temps avant que la différence ne se produise, mais rappelez-vous qu'une liste (ou tableau, ou autre) n'a aucun concept de "où vous êtes dans la liste" mais un itérateur sur cette liste/array/whatever est-ce que ce bit d'état est utile?

Answer 2

Ce que Jon a dit.

• IEnumerable ou IEnumerable<T>: en mettant en œuvre ce un objet indique qu'il peut vous donner un itérateur que vous pouvez utiliser pour traverser sur la séquence/collection/définir
• IEnumerator ou IEnumerator<T>: si vous appelez la méthode GetEnumerator définie Dans l'interface précédente, vous obtenez un objet itérateur en tant que référence IEnumerator. Cela vous permet d'appeler MoveNext() et obtenir l'objet en cours.
• foreach: est une construction/façade C# dans un sens où vous n'avez pas besoin de savoir comment cela fonctionne sous le capot. Il obtient en interne l'itérateur et appelle les bonnes méthodes pour que vous puissiez vous concentrer sur ce que vous voulez faire avec chaque élément (le contenu du bloc foreach). La plupart du temps, vous auriez besoin de foreach sauf si vous implémentez votre propre type ou itération personnalisée, auquel cas vous devez apprendre à connaître les deux premières interfaces.

Answer 3

Gardez à l'esprit que vous ne ont à mettre en œuvre IEnumerator et varients de celui-ci à utiliser foreach - IIRC, tout ce qu'il a besoin est une méthode GetEnumerator() qui retourne un objet qui a une méthode MoveNext() retour un bool, et une propriété Current retournant un objet. Vous n'avez pas besoin d'utiliser IEnumerator et IEnumerable, bien que ce soit généralement une très bonne idée de le faire. Voir here pour plus d'informations.