Puede alguien explicar IEnumerable y IEnumerator para mí?

por ejemplo, cuando a utilizar a lo largo foreach? ¿cuál es la diferencia entre IEnumerable y IEnumerator? ¿Por qué tenemos que utilizar?

  • Este es el peor de nomenclatura mixup ya que Java y JavaScript
InformationsquelleAutor prodev42 | 2009-02-17

16 Comentarios

  1. 252

    por ejemplo, cuando a utilizar a lo largo foreach?

    No uso IEnumerable «sobre» foreach. La aplicación de IEnumerable hace que el uso de foreach posible.

    Al escribir el código como:

    foreach (Foo bar in baz)
    {
       ...
    }

    es funcionalmente equivalente a la escritura:

    IEnumerator bat = baz.GetEnumerator();
    while (bat.MoveNext())
    {
       bar = (Foo)bat.Current
       ...
    }

    Por «funcionalmente equivalentes», me refiero a que en realidad lo que el compilador convierte el código en. Usted no puede utilizar foreach en baz en este ejemplo menos baz implementa IEnumerable.

    IEnumerable significa que baz implementa el método

    IEnumerator GetEnumerator()

    La IEnumerator objeto de que este método devuelve deben implementar los métodos

    bool MoveNext()

    y

    Object Current()

    El primer método avanza a la siguiente objeto en la IEnumerable objeto que creó el enumerador, volviendo false si se hace, y la segunda devuelve el objeto actual.

    Nada .Neta que se puede iterar sobre implementa IEnumerable. Si usted está construyendo su propia clase, y no ya heredar de una clase que implementa IEnumerable, usted puede hacer su clase utilizables en foreach declaraciones mediante la implementación de IEnumerable (y por la creación de una clase de enumerador de que su nuevo GetEnumerator método devolverá).

    • Creo que cuando el cartel original dijo que «más de foreach», que quería decir «cuándo debo llamar GetEnumerator() / MoveNext() explícitamente en lugar de utilizar un bucle foreach.» Para lo que vale.
    • Ah, creo que tienes razón. Bien, la respuesta está implícita en mi post: no importa, ya que el compilador lo hace de todos modos. Para hacer lo más fácil, es decir, el uso de foreach.
    • Esta respuesta no cuentan toda la historia. Enumerable objetos no necesitan implementar IEnumerable, solo se necesita tener un método GetEnumerator que devuelve una instancia de un tipo que a su vez tiene una bool MoveNext() método y un Current propiedad de cualquier tipo. Este «duck typing» enfoque fue implementado en C# 1.0 como una forma de evitar el boxeo cuando la enumeración de tipo de valor de las colecciones.
    • ¿Por qué no puede un IEnumerable clase llamada MoveNext(), Actual y Reset() directamente en lugar de devolver un IEnumerator que hace por ti?
    • Una clase puede implementar tanto IEnumerable y IEnumerator.
    • Despertar, usted probablemente significaba clase que implementa IEnumerable 🙂
    • Con el exlanation de arriba y de trabajo a través de Workthrough: la Implementación de IEnumerable de (T) ha greate fuentes.
    • Lo que estoy totalmente de menos en todo este tema (teniendo en cuenta todas las respuestas y comentarios) es que la máquina de estados de la clase que implementa la interfaz IEnumerator también puede implementar IDisposable y foreach va a poner un using bloque alrededor de la while bucle en este caso. Iterador que utilizan métodos de tryfinally (o un usingbloque) podría resultar en una máquina de estado de la clase que implementa IDisposable.
    • Es esto como una especie de C++ iterator?

  2. 142

    El IEnumerable y IEnumerator Interfaces

    Para comenzar a examinar el proceso de implementación existentes .NET interfaces, veamos primero el papel de
    IEnumerable y IEnumerator. Recordemos que C# admite una palabra clave denominada foreach que le permite
    iterar 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);
    }

    Aunque podría parecer que sólo los tipos de matriz puede hacer uso de esta construcción, la verdad del asunto es que
    cualquier tipo de apoyo a un método denominado GetEnumerator() puede ser evaluado por la construcción foreach.A
    ilustrar, que me siga!

    Supongamos que tenemos un Garaje de la clase:

    //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 para iterar sobre el Garaje del objeto de los puntos 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 informa de que el Garaje de la clase no implementa un método denominado
    GetEnumerator(). Este método es formalizada a través de la interfaz IEnumerable, que se encuentra latente en el Sistema.Colecciones de espacio de nombres.
    Clases o estructuras que apoyan este comportamiento, anuncian que son capaces de exponer contenidos
    los puntos a la persona que llama (en este ejemplo, la palabra clave foreach sí mismo). Aquí está la definición de este estándar .Interfaz de RED:

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

    Como se puede ver, la GetEnumerator() método devuelve una referencia a otra interfaz denominada
    Sistema.Las colecciones.IEnumerator. Esta interfaz proporciona la infraestructura necesaria para permitir que la persona a recorrer el interior de los objetos que contiene 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 quieres actualizar el Garaje tipo para apoyar a estas interfaces, se puede tomar el camino largo y
    aplicar cada método manualmente. Mientras que usted está ciertamente libre para proporcionar versiones personalizadas de
    GetEnumerator(), MoveNext(), Actual y Reset(), hay una manera 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 de la siguiente manera:

    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 Garaje, tipo de, usted puede utilizar con seguridad el tipo dentro de la C# construcción foreach. Además, dado que el GetEnumerator() método ha sido definido públicamente, con el objeto de usuario podría interactuar con el IEnumerator tipo:

    //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 usted prefiere ocultar la funcionalidad de IEnumerable desde el nivel del objeto, simplemente hacer
    uso explícito de la interfaz de la aplicación:

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

    Por ello, la casual de objetos de usuario no encuentra el Garaje del GetEnumerator() método, mientras que el
    construcción foreach obtendrá la interfaz en el fondo cuando sea necesario.

    Adaptado de la Pro C# 5.0 y el .NET Framework 4.5

    • Fantástica respuesta, gracias! Tengo una pregunta, sin embargo. En el primer ejemplo que recorrer el array usando foreach pero entonces usted no puede hacerlo en el segundo ejemplo. Es esto debido a que la matriz se encuentra en una clase o porque contiene objetos?
    • Gracias por la gran explicación. Mi única pregunta es, ¿por qué no tener un método en Garage que obtiene carArray? De esa manera usted no tiene que implementar GetEnumerator a sí mismo, ya Array ya lo hace. E. g. foreach(Car c in carLot.getCars()) { ... }
  3. 58

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

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

    La aplicació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...
    }

    Que es la diferencia de todos modos.

    • Agradable, esto se explica (junto con los otros puestos) cómo convertir la clase en la que usted puede utilizar «foreach» a iterar sobre su contenido.
  4. 47

    Explicación a través de Analogía + Código Tutorial

    Primero una explicación sin código, a continuación, voy a añadirlo más tarde.

    Digamos que usted está ejecutando una compañía aérea. Y en cada plano desea conocer la información sobre los pasajeros que viajen en el avión. Básicamente, usted quiere ser capaz de «atravesar» el avión. En otras palabras, usted quiere ser capaz de comenzar en el asiento delantero, y luego su forma de trabajo hacia la parte trasera del avión, pidiendo a los pasajeros información: quiénes son, de dónde vienen, etc. Un avión sólo puede hacer esto, si es:

    1. contables, y
    2. si se dispone de un contador.

    Por qué estos requisitos? Porque eso es lo que la interfaz requiere.

    Si esta es la sobrecarga de información, todo lo que usted necesita saber es que usted quiere ser capaz de preguntar a cada uno de los pasajeros del avión de algunas preguntas, a partir de la primera y a la última.

    ¿Qué contables decir?

    Si una aerolínea es «contable», esto significa que no DEBE ser un auxiliar de vuelo presentes en el avión, que la única labor es la de contar – y esta azafata de vuelo DEBE contar de una manera muy específica:

    1. El contador/asistente de vuelo DEBE comenzar antes de que el primer pasajero (en el frente de todo el mundo donde la demostración de seguridad, cómo poner la vida de la chaqueta, etc).
    2. Él/ella (es decir, el auxiliar de vuelo) DEBE «mover » siguiente» hasta el pasillo hasta el primer asiento.
    3. Él/ella es, a continuación, grabar: (i) que la persona está en el asiento, y (ii) su ubicación actual en el pasillo.

    El Procedimiento De Recuento De

    El capitán de la aerolínea quiere un informe sobre cada uno de los pasajeros como y cuando son investigados o de contado. Así que después de hablar con la persona en el primer asiento, el vuelo de operador/contador informa luego al capitán, y cuando el informe se da, el contador recuerda su posición exacta en el pasillo y sigue contando justo donde él/ella se dejó.

    De esta manera, el capitán siempre es capaz de tener información acerca de la persona que está siendo investigado. De esa manera, si él se entera de que esta persona le gusta Manchester City, entonces él puede dar que los pasajeros tratamiento preferencial etc.

    • El contador continúa hasta que se llega al final del plano.

    Vamos a vincular con la IEnumerables

    • Un enumerable es simplemente una colección de los pasajeros en un avión. La Ley de Aviación Civil – estos son, básicamente, las reglas que todos los IEnumerables debe seguir. Cada vez que el operador de la aerolínea va al capitán con el passeger información, que son, básicamente, ‘dando’ el pasajero para el capitán. El capitán, básicamente, se puede hacer lo que quiera con el pasajero – excepto la reorganización de los pasajeros en el avión. En este caso, se les da un trato preferencial si siguen Manchester City (ugh!)

      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 que es contable si tiene un contador de. Y contador debe (básicamente): (i) recordar su lugar (estado), (ii) ser capaz de mover, (iii) y saber sobre el actual persona con la que está tratando.

    Enumerable es sólo una palabra elegante para «contable». En otras palabras, un enumerable permite «enumerar» (es decir, contar).

  5. 22

    IEnumerable implementa GetEnumerator. Cuando se llama, que es el método devolverá un IEnumerator que implementa MoveNext, Restablecer y Actual.

    Así, 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.

  6. 17

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

    IEnumerator permite foreach estilo de un acceso secuencial a los elementos de la lista, usando la palabra clave yield.

    Antes de foreach aplicación (en Java 1.4, por ejemplo), el camino a recorrer en una lista para obtener un enumerador de la lista, a continuación, preguntar por la opción «siguiente» en la lista, mientras que el valor devuelto como el siguiente elemento no nulo. Foreach simplemente hace que, implícitamente, como una característica del lenguaje, de la misma manera que lock() implementa la clase Monitor detrás de las escenas.

    Espero foreach obras en las listas porque ellos implementan IEnumerable.

    • si su para una lista ¿por qué no puedo usar foreach?
    • .Red de pato tipos de la instrucción foreach, pero IEnumerable/IEnumerable<T> es la manera apropiada de decir que la clase puede ser enumerados.
  7. 15
    • Un objeto que implementa IEnumerable permite a otros a visitar cada uno de sus elementos (por un enumerador).
    • Un objeto que implementa IEnumerator es la de hacer de la iteración. Es un bucle por un objeto enumerable.

    Pensar enumerable de los objetos como de las listas, pilas, árboles.

  8. 11

    IEnumerable y IEnumerator (y sus equivalentes genéricos IEnumerable<T> y IEnumerator<T>) 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í. Permite que el bucle foreach, generadores (creo rendimiento) y debido a su pequeña interfaz se utiliza para crear apretado abstracciones. IEnumerable depende de IEnumerator.

    IEnumerator, por otro lado, proporciona un nivel ligeramente inferior de la iteración de la interfaz. Es conocido como el explícito iterador que proporciona al programador un mayor control sobre la iteración del ciclo.

    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). Compilador de apoyo permite a las características del lenguaje como foreach. En términos generales, se permite esta implícito de implementación del iterador.

    Bucle foreach

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

    Creo foreach loop es una de las razones principales para el uso IEnumerable interfaces. foreach tiene una muy sucinta de la sintaxis y muy fácil de entender en comparación con las clásicas C estilo de bucles donde usted necesita para comprobar las distintas variables para ver lo que estaba haciendo.

    rendimiento de la palabra Clave

    Probablemente menos conocido es que en el IEnumerable también permite generadores en C# con el uso de yield return y yield break declaraciones.

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

    Abstracciones

    Otro escenario común en la práctica es el uso de IEnumerable para proporcionar minimalista abstracciones. Porque es un minúsculo y la interfaz de solo lectura, se le anima a exponer tus colecciones como IEnumerable (en lugar de Lista por ejemplo). De esa manera usted es libre de cambiar su ejecución, sin romper su cliente código (Lista de cambios para un LinkedList por ejemplo).

    Gotcha

    Un comportamiento a tener en cuenta es que, en la transmisión de las implementaciones (por ejemplo, la recuperación de los datos de la fila por fila de una base de datos, en lugar de cargar todos los resultados en la memoria la primera) que no recorrer en iteración la colección más de una vez. Esto está en contraste con las colecciones en memoria como Lista, donde se puede iterar varias veces sin problemas. ReSharper, por ejemplo, tiene un código de inspección para Posibles múltiples enumeración de IEnumerable.

    IEnumerator

    IEnumerator, por otro lado, es el detrás de las escenas de la interfaz que lo hace IEnumerble-foreach-magia trabajo. Estrictamente hablando, permite explícito de los iteradores.

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

    En mi experiencia IEnumerator rara vez se utiliza en escenarios comunes, debido a su más detallado de la sintaxis y algo confuso de la semántica (al menos para mí; por ejemplo, MoveNext() devuelve un valor tan bien, que el nombre no te lo aconsejo 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 secuencia de datos el procesamiento de la biblioteca que proporciona una serie de objetos en un foreach bucle aunque detrás de las escenas, los datos fueron recogidos mediante diferentes secuencias de archivo y serialisations.

    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;   
        }
    }
  9. 8

    La aplicación de IEnumerable esencialmente significa que el objeto puede ser iterado. Esto no necesariamente significa que es un array, ya que hay ciertas listas que no puede ser indexada, pero puede enumerar ellos.

    IEnumerator es el objeto que se utiliza para realizar las iteraciones. Que los controles de movimiento de un objeto al siguiente en la lista.

    La mayoría de las veces, IEnumerable & IEnumerator se utiliza de forma transparente, como parte de un foreach bucle.

  10. 5

    Diferencias entre IEnumerable y IEnumerator :

    • IEnumerable utiliza IEnumerator internamente.
    • IEnumerable no saber qué elemento/objeto es la ejecución.
    • Cuando pasamos IEnumerator a otra función ,se sabe que la posición actual del elemento/objeto.
    • Cuando pasamos IEnumerable colección a otra función ,
      no sabe la posición actual del elemento/objeto(no saben a qué elemento de su ejecución)

      IEnumerable tener un método GetEnumerator()

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

    IEnumerator tienen una Propiedad actual y dos métodos de Reset y MoveNext(Que es útil para conocer la posición de un elemento en una lista).

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

    Una comprensión de la Iterador patrón será de utilidad para usted. Recomiendo la lectura de la misma.

    Patrón Iterador

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

    Con el fin de implementar el patrón primero necesitamos implementar un iterador para producir un concreto que se puede iterar sobre la cuestión de la colección (cliente)
    A continuación, la colección (cliente) implementa el agregador de devolver una instancia de la anterior iteración.

    Aquí está el diagrama UML
    ¿Alguien puede explicar IEnumerable y IEnumerator para mí?

    Así que, básicamente, en c#, IEnumerable es el resumen de agregado 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>

    Con el fin de contar el número de permutaciones que podemos hacer algo como lo de abajo.

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

    El compilador de c#, más o menos, convierte el anterior para

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

    Si usted tiene alguna pregunta por favor no dude en preguntar.

  12. 3

    IEnumerable es una caja que contiene Ienumerator. IEnumerable es la base de la interfaz para todas las colecciones. bucle foreach puede funcionar si la colección implementa IEnumerable. En el siguiente código se explica el paso de tener nuestro propio Enumerador. Permite definir nuestra Clase de la que vamos a hacer la colección.

    public class Customer
    {
        public String Name { get; set; }
        public String City { get; set; }
        public long Mobile { get; set; }
        public double Amount { get; set; }
    }

    Ahora vamos a definir una Clase en la que actuará como una colección para nuestra clase Cliente. Aviso de que es la implementación de la interfaz IEnumerable. Así que tenemos que implementar el método GetEnumerator. Esto devolverá nuestra costumbre Enumerador.

    public class CustomerList : IEnumerable
    {
        Customer[] customers = new Customer[4];
        public CustomerList()
        {
            customers[0] = new Customer { Name = "Bijay Thapa", City = "LA", Mobile = 9841639665, Amount = 89.45 };
            customers[1] = new Customer { Name = "Jack", City = "NYC", Mobile = 9175869002, Amount = 426.00 };
            customers[2] = new Customer { Name = "Anil min", City = "Kathmandu", Mobile = 9173694005, Amount = 5896.20 };
            customers[3] = new Customer { Name = "Jim sin", City = "Delhi", Mobile = 64214556002, Amount = 596.20 };
        }
    
        public int Count()
        {
            return customers.Count();
        }
        public Customer this[int index]
        {
            get
            {
                return customers[index];
            }
        }
        public IEnumerator GetEnumerator()
        {
            return customers.GetEnumerator(); //we can do this but we are going to make our own Enumerator
            return new CustomerEnumerator(this);
        }
    }

    Ahora vamos a crear nuestro propio Enumerador de como seguir. Así, tenemos que implementar el método MoveNext.

     public class CustomerEnumerator : IEnumerator
        {
            CustomerList coll;
            Customer CurrentCustomer;
            int currentIndex;
            public CustomerEnumerator(CustomerList customerList)
            {
                coll = customerList;
                currentIndex = -1;
            }
    
            public object Current => CurrentCustomer;
    
            public bool MoveNext()
            {
                if ((currentIndex++) >= coll.Count() - 1)
                    return false;
                else
                    CurrentCustomer = coll[currentIndex];
                return true;
            }
    
            public void Reset()
            {
                //we dont have to implement this method.
            }
        }

    Ahora podemos utilizar un bucle foreach más de nuestra colección, como el de abajo;

        class EnumeratorExample
        {
            static void Main(String[] args)
            {
    
                CustomerList custList = new CustomerList();
                foreach (Customer cust in custList)
                {
                    Console.WriteLine("Customer Name:"+cust.Name + " City Name:" + cust.City + " Mobile Number:" + cust.Amount);
                }
                Console.Read();
    
            }
        }
  13. 2

    Una contribución Menor.

    Ya que muchos de ellos explicar acerca de ‘al uso’ y ‘uso con foreach’.
    He pensado en añadir Otro Estados de la Diferencia aquí, como se pide en la pregunta acerca de la diferencia entre ambos IEnumerable un IEnumerator.

    He creado el siguiente ejemplo de código se basa 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?

    Enumerador mantiene el estado (iteración posición) entre llamadas a la función, mientras que en las iteraciones de la otra mano Enumerable no.

    Aquí está la prueba de ejemplo con comentarios de entender.

    Expertos por favor, añadir/corregir mí.

    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());
    }
    }
  14. 2

    Me he dado cuenta de estas diferencias:

    A. Podemos recorrer la lista en forma diferente, foreach puede ser utilizado para IEnumerable y bucle while para IEnumerator.

    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

  15. 1

    IEnumerable y IEnumerator ambos son interfaces en C#.

    IEnumerable es una interfaz que define un método único GetEnumerator() que devuelve un IEnumerator interfaz.

    Esto funciona para acceso de sólo lectura a una colección que implementa esa IEnumerable puede ser utilizado con un foreach declaración.

    IEnumerator tiene dos métodos, MoveNext y Reset. También tiene una propiedad llamada Current.

    Continuación se muestra la implementación de IEnumerable y IEnumerator.

  16. 0
    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
    */

Dejar respuesta

Please enter your comment!
Please enter your name here