¿Puede alguien explicar IEnumerable y IEnumerator para mí? [cerrado]
https://stackoverflow.com/questions/558304
-
05-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Puede alguien explicar IEnumerable y IEnumerator para mí?
Por ejemplo, cuándo usarlo sobre foreach? ¿cuál es la diferencia entre IEnumerable y IEnumerator? ¿Por qué necesitamos para usarlo?
Solución
Por ejemplo, cuándo usarlo sobre foreach?
Usted no usa IEnumerable "sobre" foreach. La implementación de IEnumerable hace que el uso foreach posible .
Cuando se escribe código como:
foreach (Foo bar in baz)
{
...
}
que es funcionalmente equivalente a la escritura:
IEnumerator bat = baz.GetEnumerator();
while (bat.MoveNext())
{
bar = (Foo)bat.Current
...
}
Por "funcionalmente equivalente", quiero decir que es realmente lo que el compilador convierte el código en. No se puede utilizar en foreach baz en este ejemplo a menos que baz implementa IEnumerable.
IEnumerable significa que baz implementa el método
IEnumerator GetEnumerator()
El objeto IEnumerator que devuelve este método deben implementar los métodos
bool MoveNext()
y
Object Current()
El primer método avanza al siguiente objeto en el objeto IEnumerable que creó el empadronador, volviendo false si se hace, y la segunda devuelve el objeto actual.
Cualquier cosa en .Net que se puede iterar sobre los implementos IEnumerable. Si usted está construyendo su propia clase, y que aún no heredar de una clase que implementa IEnumerable, puede hacer que su clase utilizable en declaraciones foreach mediante la implementación de IEnumerable (y mediante la creación de una clase de enumerador que su nuevo método de GetEnumerator volverá) .
Otros consejos
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. Recordemos que C # soporta un foreach llamado palabra clave 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 pueden hacer uso de esta construcción, la verdad del asunto es cualquier tipo de soporte un método denominado GetEnumerator () puede ser evaluado por el foreach construct.To ilustrar, sígueme!
Supongamos que tenemos una clase 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);
}
}
Lo ideal sería conveniente para iterar sobre los subpuntos del objeto del garage en el foreach construir, al igual que un conjunto 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 garaje no implementa un método llamado GetEnumerator (). Este método se formaliza por la interfaz IEnumerable, que se encuentra al acecho dentro del espacio de nombres System.Collections. Las clases o estructuras que soportan este comportamiento anuncian que son capaces de exponer contenida subpuntos a la persona que llama (en este ejemplo, la propia palabra clave foreach). Aquí está la definición de esta interfaz estándar de .NET:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
Como se puede ver, el método GetEnumerator () devuelve una referencia a otra interfaz sin embargo nombrado System.Collections.IEnumerator. Esta interfaz proporciona la infraestructura para permitir a la persona que llama para atravesar los objetos internos contenidas por el contenedor compatible IEnumerable-:
// 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 garaje para apoyar estas interfaces, se puede tomar el camino largo y aplicar cada método de forma manual. Mientras que usted está ciertamente libre para proporcionar versiones personalizadas de GetEnumerator (), MoveNext (), actual, y Reset (), no hay una manera más sencilla. Como el tipo System.array (así como muchas otras clases de colección) ya implementa IEnumerable y IEnumerator, simplemente puede delegar la petición a la System.array 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 el tipo de garaje, se puede utilizar con seguridad el tipo dentro de la construcción de C # foreach. Además, dado que el método GetEnumerator () ha sido definido públicamente, el usuario objeto también podría interactuar con el tipo IEnumerator:
// 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 de objeto, simplemente hacer uso de implementación de interfaz explícita:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
De este modo, el usuario ocasional objeto no encontrará el método del garaje GetEnumerator (), mientras que el construcción foreach obtendrá la interfaz en el fondo cuando sea necesario.
Adaptado de la Pro C # 5.0 y .NET Framework 4.5
Implementación de IEnumerable significa que su clase devuelve un objeto IEnumerator:
public class People : IEnumerable
{
IEnumerator IEnumerable.GetEnumerator()
{
// return a PeopleEnumerator
}
}
Implementar 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 través de Analogía + Código Tutorial
En primer lugar una explicación sin código, a continuación, voy a añadir más tarde.
Digamos que usted está ejecutando una compañía aérea. Y en cada plano que desea conocer información sobre los pasajeros que vuelan en el avión. Básicamente, usted quiere ser capaz de "recorrer" el avión. En otras palabras, usted quiere ser capaz de iniciar en el asiento delantero, y su forma de trabajo hacia la parte trasera del avión, pidiendo a los pasajeros información: quiénes son, de dónde son, etc. Un avión sólo puede hacer esto , si es:
- contable, y
- si se dispone de un contador.
¿Por qué estos requisitos? Porque eso es lo que requiere la interfaz.
Si esta es la sobrecarga de información, todo lo que necesita saber es que usted quiere ser capaz de pedir a cada pasajero en el avión a algunas preguntas, a partir de la primera y hacer su camino hasta el final.
¿Qué significa contable?
Si una compañía aérea es "contable", esto significa que debe ser un asistente de vuelo presente en el avión, que es único trabajo consiste en contar - y esto azafata debe contar de una manera muy específica:
- El responsable de la ventanilla / vuelo debe comenzar antes de que el primer pasajero (en el frente de todo el mundo en el que la seguridad de demostración, la forma de poner el chaleco salvavidas en el etc).
- El / ella (es decir, el auxiliar de vuelo) debe "moverse al lado" por el pasillo hacia el primer asiento.
- El / ella es a continuación registro:. (I) que la persona está en el asiento, y (ii) su ubicación actual en el pasillo
Contando Procedimientos
El capitán de la aerolínea quiere un informe sobre cada pasajero como y cuando se investigan o contados. Así que después de hablar con la persona en el primer asiento, el vuelo de la operadora / contador informa luego al capitán, y cuando se da el informe, el contador se acuerda de su / su posición exacta en el pasillo y sigue contando justo donde él / ella dejó off.
De esta manera, el capitán es siempre capaz de tener información sobre la persona actual que está siendo investigado. De esta manera, si se entera de que este individuo le gusta el Manchester City, entonces él puede dar ese trato preferencial de pasajeros, etc.
- El contador sigue funcionando hasta que se llega al final del avión.
Atemos esto con el IEnumerables
-
Un enumerable es sólo una colección de pasajeros de un avión. La Ley de Aviación Civil - estos son básicamente las reglas que deben seguir todos los IEnumerables. Cada vez que el encargado compañía aérea entra al capitán con la información passeger, básicamente estamos 'rendimiento' del pasajero con el capitán. El capitán puede hacer básicamente lo que quiera con el pasajero - excepto la reordenación de los pasajeros en el avión. En este caso, se les da un tratamiento preferencial si siguen el 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 que es numerable si tiene un contador . Y el contador debe (básicamente): (i) Recuerdo su lugar ( Estado ), (ii) ser capaz de mover al lado , (iii) y sé de la persona corriente que está tratando.
Enumerable es sólo una palabra elegante para "contable". En otras palabras, un enumerable le permite 'enumeración' (es decir, recuento).
IEnumerable implementa GetEnumerator. Cuando se llama, ese método devolverá un IEnumerator que implementa MoveNext, Reset y actual.
Así, cuando su 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.
Implementación de IEnumerable le permite obtener un IEnumerator para obtener una lista.
IEnumerator permite estilo foreach acceso secuencial a los elementos de la lista, usando la palabra clave de rendimiento.
Antes de la implementación foreach (en Java 1.4, por ejemplo), el camino a recorrer una lista era conseguir un enumerador de la lista, a continuación, pedir que para el elemento "siguiente" en la lista, durante el tiempo que el valor devuelto como el siguiente artículo no es nulo. Foreach simplemente hace que implícitamente como una característica del lenguaje, de la misma manera que el bloqueo () implementa la clase monitor detrás de las escenas.
espero foreach funciona en las listas porque implementan IEnumerable.
- Un objeto que implementa IEnumerable permite a otros a visitar cada uno de sus elementos (el encuestador) .
- Un objeto que implementa IEnumerator es la de hacer la iteración. Se bucle sobre un objeto enumerable.
Piense en objetos enumerables como de las listas, pilas, árboles.
IEnumerable y IEnumerator (y sus homólogos genéricos IEnumerable
IEnumerable es la interfaz más común que se ven en la mayor parte del código que hay. Permite que el bucle foreach, generadores (piensan rendimiento ) y debido a su pequeña interfaz, se utiliza para crear abstracciones apretados. IEnumerable depende de IEnumerator .
IEnumerator , por otro lado, proporciona una interfaz de nivel de iteración ligeramente inferior. Se conoce como los href="https://en.wikipedia.org/wiki/Iterator#C.23_and_other_.NET_languages" iterador explícita que 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 lo soporta (de hecho, todos los tipos de colección que se me ocurre hoy implementos IEnumerable ). compilador de soporte permite que las características del lenguaje como foreach. En términos generales, que permite a este implícita aplicación iterador .
foreach bucle
foreach (var value in list)
Console.WriteLine(value);
Creo bucle foreach es una de las principales razones para utilizar IEnumerable interfaces. foreach tiene una sintaxis muy breve y muy fácil de entender en comparación con el clásico C estilo de bucles en las que necesita para comprobar las diferentes variables para ver lo que estaba haciendo.
producir palabra clave
Probablemente una característica menos conocida es que IEnumerable también permite generadores en C # con el uso de declaraciones 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 se usa IEnumerable para proporcionar abstracciones minimalistas. Debido a que es una interfaz minúscula y de sólo lectura, se le anima a exponer sus colecciones como IEnumerable (en lugar de , por ejemplo). De esa manera usted es libre de cambiar de aplicación sin romper (Lista cambio a un LinkedList por ejemplo) el código de su cliente.
Gotcha
Un comportamiento a tener en cuenta es que en las implementaciones de transmisión (por ejemplo, la recuperación de fila de datos de fila de una base de datos, en lugar de cargar todos los resultados en memoria primero) que no pueden iterar sobre la colección de más de una vez. Esto está en contraste con colecciones en la memoria como , donde se puede repetir varias veces sin problemas. ReSharper, por ejemplo, tiene una inspección de código de Posible enumeración múltiplo de IEnumerable .
IEnumerator
IEnumerator, por el contrario, es el detrás de la interfaz de escenas que hace IEnumerble-foreach-magia trabajo. En sentido estricto, permite iteradores explícitas.
var iter = list.GetEnumerator();
while (iter.MoveNext())
Console.WriteLine(iter.Current);
En mi experiencia IEnumerator se utiliza raramente en los escenarios más comunes debido a su sintaxis más detallado y la semántica ligeramente confusos (al menos a mí, por ejemplo, MoveNext () devuelve un valor además, que el nombre no sugiere en absoluto).
casos de uso para IEnumerator
I sólo se utiliza IEnumerator , en particular, las bibliotecas (nivel ligeramente inferior) y los marcos de donde estaba proporcionando IEnumerable interfaces. Un ejemplo es una biblioteca de procesamiento de flujo de datos wHICH proporcionado serie de objetos en un bucle foreach a pesar de que detrás de las escenas de datos se recolectaron utilizando varias secuencias de archivo y seriaciones.
El 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;
}
}
Implementación IEnumerable esencialmente significa que el objeto puede repetirse de nuevo. Esto no significa necesariamente que es una matriz, ya que hay ciertas listas que no pueden ser indexados, pero se puede enumerarlos.
IEnumerator es el objeto real que se utiliza para realizar las iteraciones. Controla en movimiento de un objeto a la siguiente en la lista.
La mayoría de las veces, IEnumerable y IEnumerator se utilizan de forma transparente como parte de un bucle foreach.
Diferencias entre IEnumerable y IEnumerator:
- IEnumerable utiliza IEnumerator internamente.
- IEnumerable doesnt sabe qué elemento / objeto se está ejecutando.
- Cada vez que pasamos IEnumerator a otra función, se conoce la posición actual del punto / objeto.
-
Siempre que pasamos colección IEnumerable a otra función, no conoce la posición actual del punto / objeto (no sabe qué elemento de su ejecución)
IEnumerable tiene un método GetEnumerator ()
public interface IEnumerable<out T> : IEnumerable { IEnumerator<T> GetEnumerator(); }
IEnumerator tener una propiedad actual 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 iterador será útil para usted. Recomiendo la lectura de la misma.
En un nivel alto el iterador se puede utilizar para proporcionar una forma estándar de iteración a través de colecciones de cualquier tipo. Tenemos 3 participantes en el iterador, la colección real (cliente), el agregador y el iterador. El agregado es una clase de interfaz / extracto que tiene un método que devuelve un iterador. Iterador es una clase de interfaz / 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 tenemos que aplicar un iterador para producir un concreto que puede 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 anteriormente.
Aquí está el diagrama de UML
Así que, básicamente, en C #, IEnumerable es el conjunto abstracto y IEnumerator es el iterador abstracto. IEnumerable tiene una sola GetEnumerator método que es responsable de crear una instancia de IEnumerator del tipo deseado. Colecciones como listas de implementar el IEnumerable.
Ejemplo.
Vamos a suponer que tenemos una getPermutations(inputString) método 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 podríamos 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 la de arriba para
using (var permutationIterator = perm.getPermutations(input).GetEnumerator())
{
while (permutationIterator.MoveNext())
{
count++;
}
}
Si tiene alguna pregunta, por favor no dude en preguntar.
IEnumerable es una caja que contiene IEnumerator. IEnumerable es interfaz base para todas las colecciones. bucle foreach puede funcionar si la colección implementa IEnumerable. En el código siguiente se explica el paso de tener nuestro propio enumerador. Vamos a definir en primer lugar 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 la clase que actuará como una colección para nuestra clase Cliente. Observe que está implementando la interfaz IEnumerable. Así que tenemos que poner en práctica el método GetEnumerator. Esto devolverá nuestra enumerador personalizado.
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 encargo de la siguiente manera. Por lo tanto, 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 usar bucle foreach más de nuestra colección, como a continuación;
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();
}
}
una contribución menor.
Como muchos de ellos a explicar acerca de 'cuándo utilizar' y 'utilizar con foreach'. Pensé en la adición de otro Estados Diferencia aquí como solicitada en la pregunta sobre la diferencia entre ambos IEnumerable un IEnumerator.
He creado el siguiente ejemplo de código en base a las siguientes líneas de discusión.
IEnumerable, IEnumerator vs foreach, cuándo utilizar lo ¿Cuál es la diferencia entre IEnumerator y IEnumerable?
Enumerador conserva la (posición de iteración) de estado entre llamadas de función mientras iteraciones otra parte Enumerable no lo hace.
Aquí está el ejemplo probado con los comentarios de entender.
Los expertos deben añadir / me corrija.
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 dado cuenta de estas diferencias:
A. Iteramos mencionados de forma diferente, foreach puede ser utilizado para IEnumerable y bucle while para IEnumerator.
B. IEnumerator puede recordar el índice actual cuando se pasa de un método a otro (que empezar a trabajar con el índice actual), pero IEnumerable no puede recordar el índice y restablecer el índice de inicio. Más en este video https://www.youtube.com/watch?v=jd3yUjGc9M0
IEnumerable y IEnumerator ambos son interfaces en C #.
IEnumerable es una interfaz que define un único GetEnumerator() método que devuelve una interfaz IEnumerator.
Esto funciona para acceso de sólo lectura a una colección que implementa esa IEnumerable se puede utilizar con una declaración foreach.
IEnumerator tiene dos métodos, MoveNext y Reset. También tiene una propiedad llamada Current.
A continuación se muestra la ejecución de IEnumerable y IEnumerator.
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
*/
