El IEnumerable y IEnumerator Interfaces

Para comenzar a examinar el proceso de implementación de interfaces. NET existentes, veamos primero el papel de IEnumerable y IEnumerator. Recuerde que C# admite una palabra clave llamada foreach que le permite itera sobre el contenido de cualquier tipo de matriz:

// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
   Console.WriteLine(i);
}

Si bien podría parecer que solo los tipos de matriz pueden hacer uso de esta construcción, la verdad de la materia es cualquier tipo que soporte un método llamado GetEnumerator () puede ser evaluado por el foreach construct.To ilustre, sígame!

Supongamos que tenemos una clase de Garaje:

// Garage contains a set of Car objects.
public class Garage
{
   private Car[] carArray = new Car[4];
   // Fill with some Car objects upon startup.
   public Garage()
   {
      carArray[0] = new Car("Rusty", 30);
      carArray[1] = new Car("Clunker", 55);
      carArray[2] = new Car("Zippy", 30);
      carArray[3] = new Car("Fred", 30);
   }
}

Idealmente, sería conveniente iterar sobre los subítems del objeto Garage usando el foreach construir, al igual que una matriz de valores de datos:

// This seems reasonable ...
public class Program
{
   static void Main(string[] args)
   {
      Console.WriteLine("***** Fun with IEnumerable / IEnumerator *****\n");
      Garage carLot = new Garage();
      // Hand over each car in the collection?
      foreach (Car c in carLot)
      {
         Console.WriteLine("{0} is going {1} MPH",
         c.PetName, c.CurrentSpeed);
      }
      Console.ReadLine();
   }
}

Lamentablemente, el compilador le informa que la clase Garage no implementa un método llamado GetEnumerator(). Este método es formalizado por la interfazumumerable, que se encuentra al acecho dentro del Sistema.Colecciones espacio de nombres. Las clases o estructuras que soportan este comportamiento anuncian que son capaces de exponer contenidos subtemas para el llamante(en este ejemplo, la palabra clave foreach). Aquí está la definición de esta interfaz. NET estándar:

// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
   IEnumerator GetEnumerator();
}

Como puedes ver, el método GetEnumerator () devuelve una referencia a otra interfaz llamada Sistema.Colecciones.IEnumerator. Esta interfaz proporciona la infraestructura para permitir que el llamante atraviese los objetos internos contenidos por el IEnumerable-compatible contenedor:

// This interface allows the caller to
// obtain a container's subitems.
public interface IEnumerator
{
   bool MoveNext (); // Advance the internal position of the cursor.
   object Current { get;} // Get the current item (read-only property).
   void Reset (); // Reset the cursor before the first member.
}

Si desea actualizar el tipo de garaje para admitir estas interfaces, podría tomar el largo camino y implemente cada método manualmente. Mientras que usted es sin duda libre de proporcionar versiones personalizadas de GetEnumerator (), MoveNext (), Current y Reset (), hay una forma más sencilla. Como el Sistema.Tipo de matriz (así como muchas otras clases de colección) ya implementa IEnumerable y IEnumerator, usted puede simplemente delegar la solicitud al Sistema.Matriz como sigue:

using System.Collections;
...
public class Garage : IEnumerable
{
   // System.Array already implements IEnumerator!
   private Car[] carArray = new Car[4];
   public Garage()
   {
      carArray[0] = new Car("FeeFee", 200);
      carArray[1] = new Car("Clunker", 90);
      carArray[2] = new Car("Zippy", 30);
      carArray[3] = new Car("Fred", 30);
   }
   public IEnumerator GetEnumerator()
   {
      // Return the array object's IEnumerator.
      return carArray.GetEnumerator();
   }
}

Después de haber actualizado su tipo de garaje, puede usar el tipo de forma segura dentro de la construcción C# foreach. Además, dado que el método GetEnumerator() ha sido definido públicamente, el usuario del objeto también podría interactuar con el tipo Getumerator:

// Manually work with IEnumerator.
IEnumerator i = carLot.GetEnumerator();
i.MoveNext();
Car myCar = (Car)i.Current;
Console.WriteLine("{0} is going {1} MPH", myCar.PetName, myCar.CurrentSpeed);

Sin embargo, si prefiere ocultar la funcionalidad deerableumerable desde el nivel de objeto, simplemente haga uso de implementación de interfaz explícita:

IEnumerator IEnumerable.GetEnumerator()
{
  // Return the array object's IEnumerator.
  return carArray.GetEnumerator();
}

Al hacerlo, el usuario del objeto casual no buscar el método GetEnumerator() del Garaje, mientras que el foreach construct obtendrá la interfaz en segundo plano cuando sea necesario.

Adaptado de Pro C # 5.0 y. NET 4.5 Framework

La Implementación de IEnumerable significa que su clase devuelve un IEnumerator objeto:

public class People : IEnumerable
{
    IEnumerator IEnumerable.GetEnumerator()
    {
        // return a PeopleEnumerator
    }
}

La Implementación de IEnumerator significa que su clase devuelve los métodos y propiedades para la iteración:

public class PeopleEnumerator : IEnumerator
{
    public void Reset()...

    public bool MoveNext()...

    public object Current...
}

Esa es la diferencia de todos modos.

Explicación vía Analogía + Tutorial de Código

Primero una explicación sin código, luego la agregaré más tarde.

Digamos que estás dirigiendo una compañía aérea. Y en cada avión que desea saber información sobre los pasajeros que vuelan en el avión. Básicamente quieres ser capaz de "atravesar" el avión. En otras palabras, usted quiere ser capaz de comenzar en el asiento delantero, y luego trabajar su camino hacia la parte posterior del avión, pidiendo a los pasajeros alguna información: quiénes son, de dónde son, etc. Un avión solo puede hacer esto, si es:

1. contable, y
2. si tiene un contador.

Si no hay 'contador', y si no es 'contable', no llegará muy lejos. ¿Por qué estos requisitos? Porque eso es lo que requiere la interfaz.

¿Qué significa contable?

Si una aerolínea es "contable", esto significa que DEBE haber un asistente de vuelo presente en el avión, cuyo único trabajo es contar - y esta azafata DEBE contar de una manera muy específica (de acuerdo con las Leyes de Aviación Civil):

1. El contador/asistente de vuelo DEBE comenzar antes que el primer pasajero (en la parte delantera de todos donde demuestren la seguridad, cómo ponerse el chaleco salvavidas, etc.).
2. Él/ella (es decir, la azafata) DEBE "moverse a continuación" por el pasillo hasta el primer asiento.
3. Él/ella debe entonces registrar: (i) quién es la persona en el asiento, y (ii) su ubicación actual en el pasillo.

Procedimientos De Conteo

El capitán de la aerolínea quiere un informe sobre cada pasajero a medida que se investigan o cuentan. Así que después de hablar con la persona en el primer asiento, el asistente de vuelo/contador luego informa al capitán, y cuando se da el informe, el contador recuerda su posición exacta en el pasillo y continúa contando justo donde lo dejó.

De esta manera el capitán siempre puede tener información sobre la persona que está siendo investigada. De esa manera, si descubre que a este individuo le gusta el Manchester City, entonces puede darle a ese pasajero un trato preferencial, etc.

• El contador continúa hasta que llega al final del avión.

Atemos esto con losumumerables

• Un enumerable es solo una colección de pasajeros en un avión. La Ley de aviación Civil-estas son básicamente las normas que todos losumumerables deben seguir. Cada vez que el asistente de la aerolínea va al capitán con la información del passeger, básicamente estamos "cediendo" al pasajero al capitán. El capitán básicamente puede hacer lo que quiera con el pasajero, excepto reorganizar a los pasajeros en el avión. En este caso, se les da un trato preferencial si siguen al Manchester City (¡uf!)

  foreach (Passenger passenger in Plane)
  // the airline hostess is now at the front of the plane
  // and slowly making her way towards the back
  // when she get to a particular passenger she gets some information
  // about the passenger and then immediately heads to the cabin
  // to let the captain decide what to do with it
  { // <---------- Note the curly bracket that is here.
      // we are now cockpit of the plane with the captain.
      // the captain wants to give the passenger free 
      // champaign if they support manchester city
      if (passenger.supports_mancestercity())
      {
          passenger.getFreeChampaign();
      } else
      {
          // you get nothing! GOOD DAY SIR!
      }
  } //  <---- Note the curly bracket that is here!
        the hostess has delivered the information 
        to the captain and goes to the next person
        on the plane (if she has not reached the 
        end of the plane)
  

Resumen

En otras palabras, algo es contable si tiene un contador. Y contador debe (básicamente): (i) recordar su lugar (estado), (ii) ser capaz de mover siguiente, (iii) y saber acerca de la actual persona con la que está tratando.

Enumerable es solo una palabra elegante para "numerable". En otras palabras, un enumerable le permite 'enumerar' (es decir, contar).

IEnumerable implementa GetEnumerator. Cuando se llama, ese método devolverá un {[3] }umumerator que implementa MoveNext, Reset y Current.

Por Lo tanto, cuando la clase implementa IEnumerable, usted está diciendo que usted puede llamar a un método (GetEnumerator) y obtener un nuevo objeto devuelto (un IEnumerator) se puede utilizar en un bucle como foreach.

La Implementación de IEnumerable le permite obtener un IEnumerator para una lista.

Iumerator permite el acceso secuencial de cada estilo a los elementos de la lista, utilizando la palabra clave yield.

Antes de la implementación de foreach (en Java 1.4, por ejemplo), la forma de iterar una lista era obtener un enumerador de la lista, y luego pedirle el elemento "siguiente" de la lista, siempre y cuando el valor devuelto como el elemento siguiente no sea nulo. Foreach simplemente lo hace implícitamente como una característica del lenguaje, en de la misma manera que lock() implementa la clase Monitor detrás de escena.

Espero que foreach funcione en listas porque implementanerableumerable.

• Un objeto que implementa IEnumerable permite a otros a visitar cada uno de sus elementos (por un enumerador).
• Un objeto que implementa IEnumerator es el de hacer de la iteración. Está en bucle sobre un objeto enumerable.

Piense en objetos enumerables como listas, pilas, árboles.

IEnumerable y IEnumerator (y sus equivalentes genéricos IEnumerable y IEnumerator) son la base de las interfaces de iterador implementaciones en .Net Framework Class Libray colecciones.

IEnumerable es la interfaz más comunes que se ven en la mayoría del código por ahí. Habilita el bucle foreach, generadores (think yield) y debido a su pequeña interfaz, se usa para crear abstracciones apretadas. IEnumerable depende de IEnumerator.

Iumerator, por otro lado, proporciona una interfaz de iteración de nivel ligeramente inferior. Se conoce como el iterador explícito que le da al programador más control sobre el ciclo de iteración.

IEnumerable

IEnumerable es una interfaz estándar que permite iterar sobre colecciones que la soporta (de hecho, todos los tipos de colección que puedo pensar de hoy implementa IEnumerable). Soporte para compiladores permite funciones de lenguaje como foreach. En términos generales, habilita esta implementación de iterador implícito .

Bucle Foreach

foreach (var value in list)
  Console.WriteLine(value);

Creo que el bucle foreaches una de las principales razones para usar interfacesumumerables. foreach tiene una sintaxis muy sucinta y muy fácil de entender en comparación con el estilo clásico C para bucles donde necesita verificar las diversas variables para ver qué estaba haciendo.

Palabra clave de rendimiento

Probablemente un menor la característica conocida es que {[18] }umumerable también habilita generadores en C# con el uso de las sentencias yield return y yield break.

IEnumerable<Thing> GetThings() {
   if (isNotReady) yield break;
   while (thereIsMore)
     yield return GetOneMoreThing();
}

Abstracciones

Otro escenario común en la práctica es usar {[18] }umumerable para proporcionar abstracciones minimalistas. Debido a que es una interfaz minúscula y de solo lectura, se le recomienda exponer sus colecciones como {[18] }umumerable (en lugar de List, por ejemplo). De esa manera usted es libre de cambiar su implementación sin romper el código de su cliente (cambie la lista a LinkedList por ejemplo).

Gotcha

Un comportamiento a tener en cuenta es que en las implementaciones de streaming (por ejemplo, recuperar datos fila por fila de una base de datos, en lugar de cargar todos los resultados en la memoria primero) no puede iterar sobre la colección más de una vez. Esto contrasta con las colecciones en memoria como List, donde puede iterar varias veces sin problemas. ReSharper, por ejemplo, tiene una inspección de código para Posible enumeración múltiple deerableumerable.

IEnumerator

Iumerator, por otro lado, es la interfaz detrás de escena que hace que foreumerble-foreach-magic funcione. Estrictamente hablando, habilita iteradores explícitos.

var iter = list.GetEnumerator();
while (iter.MoveNext())
    Console.WriteLine(iter.Current);

En mi experiencia {[18] }eratorumerator rara vez se usa en escenarios comunes debido a su sintaxis más detallada y semántica ligeramente confusa (en al menos para mí; por ejemplo, MoveNext() también devuelve un valor, que el nombre no sugiere en absoluto).

Caso de Uso para IEnumerator

Yo sólo se utiliza IEnumerator en particular (nivel ligeramente inferior), las librerías y frameworks donde yo estaba proporcionando IEnumerable interfaces. Un ejemplo es una biblioteca de procesamiento de flujo de datos que proporcionó una serie de objetos en un bucle foreach a pesar de que los datos entre bastidores se recopilaron utilizando varios flujos de archivos y serializaciones.

Código de Cliente

foreach(var item in feed.GetItems())
    Console.WriteLine(item);

Biblioteca

IEnumerable GetItems() {
    return new FeedIterator(_fileNames)
}

class FeedIterator: IEnumerable {
    IEnumerator GetEnumerator() {
        return new FeedExplicitIterator(_stream);
    }
}

class FeedExplicitIterator: IEnumerator {
    DataItem _current;

    bool MoveNext() {
        _current = ReadMoreFromStream();
        return _current != null;           
    }

    DataItem Current() {
        return _current;   
    }
}

Implementar IEnumerable esencialmente significa que el objeto puede ser iterado. Esto no significa necesariamente que sea una matriz, ya que hay ciertas listas que no se pueden indexar, pero se pueden enumerar.

IEnumerator es el objeto real utilizado para realizar las iteraciones. Controla el movimiento de un objeto al siguiente en la lista.

La mayor parte del tiempo, IEnumerable & IEnumerator se utilizan de forma transparente como parte de un bucle foreach.

Diferencias entre IEnumerable y IEnumerator :

• IEnumerable utiliza IEnumerator internamente.
• Iumerable no sabe qué elemento/objeto se está ejecutando.
• Cada vez que pasamos Iumerator a otra función ,conoce la posición actual de item/object.

• Cada vez que pasamos IEnumerable colección a otra función , no conoce la posición actual del elemento / objeto(no sabe qué elemento es ejecución)

  IEnumerable tener un método GetEnumerator()

public interface IEnumerable<out T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}

Iumerator tiene una propiedad current y dos métodos Reset y MoveNext (Que es útil para conocer la posición actual de un elemento en una lista).

public interface IEnumerator
{
     object Current { get; }
     bool MoveNext();
     void Reset();
}

Una comprensión del patrón Iterador será útil para usted. Recomiendo leer lo mismo.

Patrón iterador

En un nivel alto, el patrón iterador se puede usar para proporcionar una forma estándar de iterar a través de colecciones de cualquier tipo. Tenemos 3 participantes en el patrón iterador, la colección real (cliente), el agregador y el iterador. El agregado es una clase de interfaz/abstracta que tiene un método que devuelve un iterador. Iterador es un interfaz / clase abstracta que tiene métodos que nos permiten iterar a través de una colección.

Para implementar el patrón primero necesitamos implementar un iterador para producir un concreto que pueda iterar sobre la colección en cuestión (cliente) A continuación, la colección (cliente) implementa el agregador para devolver una instancia del iterador anterior.

Aquí está el diagrama UML

Así que básicamente en c# ,erableumerable es el agregado abstracto y IEnumerator es el resumen de un Iterador. IEnumerable tiene un único método GetEnumerator que se encarga de crear una instancia de la interfaz IEnumerator del tipo deseado. Colecciones como las Listas de implementar la interfaz IEnumerable.

Ejemplo. Supongamos que tenemos un método getPermutations(inputString) que devuelve todas las permutaciones de una cadena y que el método devuelve una instancia de IEnumerable<string>

Para contar el número de permutaciones podríamos hacer algo como lo siguiente.

 int count = 0;
        var permutations = perm.getPermutations(inputString);
        foreach (string permutation in permutations)
        {
            count++;
        }

La c# compilador más o menos convierte lo anterior a

using (var permutationIterator = perm.getPermutations(input).GetEnumerator())
        {
            while (permutationIterator.MoveNext())
            {
                count++;
            }
        }

Si tiene alguna pregunta, no dude en preguntar.

Una contribución Menor.

Como muchos de ellos explican acerca de 'cuándo usar' y 'usar con foreach'. Pensé en agregar Otro Establece la Diferencia aquí como se solicitó en la pregunta sobre la diferencia entre amboserableumerable unEnumerator.

Creé el siguiente ejemplo de código basado en los siguientes hilos de discusión.

IEnumerable , IEnumerator vs foreach, cuando el uso de lo que ¿Cuál es la diferencia entre IEnumerator y IEnumerable?

El enumerador conserva el estado (posición de iteración) entre las llamadas a la función, mientras que las iteraciones del otro lado Enumerable no lo hace.

Aquí está el ejemplo probado con comentarios para entender.

Expertos por favor añadir / corregirme.

static void EnumerableVsEnumeratorStateTest()
{
    IList<int> numList = new List<int>();

    numList.Add(1);
    numList.Add(2);
    numList.Add(3);
    numList.Add(4);
    numList.Add(5);
    numList.Add(6);

    Console.WriteLine("Using Enumerator - Remembers the state");
    IterateFrom1to3(numList.GetEnumerator());

    Console.WriteLine("Using Enumerable - Does not Remembers the state");
    IterateFrom1to3Eb(numList);

    Console.WriteLine("Using Enumerable - 2nd functions start from the item 1 in the collection");
}

static void IterateFrom1to3(IEnumerator<int> numColl)
{
    while (numColl.MoveNext())
    {
        Console.WriteLine(numColl.Current.ToString());

        if (numColl.Current > 3)
        {
            // This method called 3 times for 3 items (4,5,6) in the collection. 
            // It remembers the state and displays the continued values.
            IterateFrom3to6(numColl);
        }
    }
}

static void IterateFrom3to6(IEnumerator<int> numColl)
{
    while (numColl.MoveNext())
    {
        Console.WriteLine(numColl.Current.ToString());
    }
}

static void IterateFrom1to3Eb(IEnumerable<int> numColl)
{
    foreach (int num in numColl)
    {
        Console.WriteLine(num.ToString());

        if (num>= 5)
        {
            // The below method invokes for the last 2 items.
            //Since it doesnot persists the state it will displays entire collection 2 times.
            IterateFrom3to6Eb(numColl);
        }
    }
}

static void IterateFrom3to6Eb(IEnumerable<int> numColl)
{
    Console.WriteLine();
    foreach (int num in numColl)
    {
        Console.WriteLine(num.ToString());
    }
}

He notado estas diferencias:

A. Iteramos la lista de manera diferente, foreach se puede usar paraEnumerable y while loop para whileumerator.

B. IEnumerator puede recordar el índice actual cuando pasamos de una a otra (es empezar a trabajar con el índice actual) pero IEnumerable no puede recordar el índice y restablecer el índice de comenzar. Más en este video https://www.youtube.com/watch?v=jd3yUjGc9M0

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Enudemo
{

    class Person
    {
        string name = "";
        int roll;

        public Person(string name, int roll)
        {
            this.name = name;
            this.roll = roll;
        }

        public override string ToString()
        {
            return string.Format("Name : " + name + "\t Roll : " + roll);
        }

    }


    class Demo : IEnumerable
    {
        ArrayList list1 = new ArrayList();

        public Demo()
        {
            list1.Add(new Person("Shahriar", 332));
            list1.Add(new Person("Sujon", 333));
            list1.Add(new Person("Sumona", 334));
            list1.Add(new Person("Shakil", 335));
            list1.Add(new Person("Shruti", 336));
        }

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



    class Program
    {
        static void Main(string[] args)
        {
            Demo d = new Demo();  // Notice here. it is simple object but for 
                                //IEnumerator you can get the collection data

            foreach (Person X in d)
            {
                Console.WriteLine(X);
            }

            Console.ReadKey();
        }
    }
}
/*
Output : 

Name : Shahriar  Roll : 332
Name : Sujon     Roll : 333
Name : Sumona    Roll : 334
Name : Shakil    Roll : 335
Name : Shruti    Roll : 336
  */