Quelqu'un peut-il expliquer IEnumerable et IEnumerator à moi? [fermé]
https://stackoverflow.com/questions/558304
-
05-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Quelqu'un peut-il expliquer IEnumerable et IEnumerator à moi?
par exemple, quand l'utiliser sur foreach? Quelle est la différence entre IEnumerable et IEnumerator? Pourquoi avons-nous besoin de l'utiliser?
La solution
par exemple, quand l'utiliser sur foreach?
Vous n'utilisez pas IEnumerable "sur" foreach. La mise en œuvre IEnumerable fait à l'aide foreach possible .
Lorsque vous écrivez du code comme:
foreach (Foo bar in baz)
{
...
}
il est fonctionnellement équivalent à l'écriture:
IEnumerator bat = baz.GetEnumerator();
while (bat.MoveNext())
{
bar = (Foo)bat.Current
...
}
Par « fonctionnellement équivalent », je veux dire que ce fait ce que le compilateur transforme le code en. Vous ne pouvez pas utiliser foreach sur baz dans cet exemple à moins que baz implémente IEnumerable.
IEnumerable signifie que baz implémente la méthode
IEnumerator GetEnumerator()
L'objet IEnumerator que cette méthode est retournée doivent mettre en œuvre les méthodes
bool MoveNext()
et
Object Current()
La première méthode passe à l'objet suivant dans l'objet IEnumerable qui a créé le recenseur, le retour false si elle est effectuée, et le deuxième renvoie l'objet courant.
Tout en .Net que vous pouvez itérer sur des outils IEnumerable. Si vous construisez votre propre classe, et il ne hérite déjà d'une classe qui implémente IEnumerable, vous pouvez rendre votre classe utilisable dans les déclarations de foreach en mettant en œuvre IEnumerable (et en créant une classe recenseur que sa nouvelle méthode de GetEnumerator sera de retour) .
Autres conseils
Les interfaces IEnumerable et IEnumerator
Pour commencer à examiner le processus de mise en œuvre des interfaces .NET existantes, regardons d'abord le rôle de IEnumerable et IEnumerator. Rappelons que C # prend en charge un mot-clé nommé foreach qui vous permet de effectuer une itération sur le contenu de tout type de réseau:
// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
Console.WriteLine(i);
}
Bien qu'il puisse sembler que seuls les types de tableaux peuvent utiliser cette construction, la vérité de la question est tout type de support d'une méthode appelée GetEnumerator () peut être évaluée par le foreach construct.To illustrer, suivez-moi!
Supposons que nous ayons une classe Garage:
// 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);
}
}
Idéalement, il serait commode de itérer sur les sous-éléments de l'objet Garage à l'aide du foreach construire, comme un tableau de valeurs de données:
// 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();
}
}
Malheureusement, le compilateur vous informe que la classe Garage ne met pas en œuvre une méthode nommée GetEnumerator (). Cette méthode est formalisée par l'interface IEnumerable, qui se trouve tapi au sein de l'espace de noms System.Collections. Classes ou structures qui prennent en charge ce comportement annoncent qu'ils sont en mesure d'exposer contenue à l'appelant sous-éléments (dans cet exemple, le mot-clé foreach lui-même). Voici la définition de cette interface .NET standard:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
Comme vous pouvez le voir, la méthode GetEnumerator () renvoie une référence à une autre interface nommée System.Collections.IEnumerator. Cette interface fournit l'infrastructure pour permettre à l'appelant de traverser les objets internes contenus par le récipient IEnumerable compatible:
// 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 vous souhaitez mettre à jour le type de garage pour soutenir ces interfaces, vous pouvez prendre la longue route et mettre en oeuvre chaque procédé manuellement. Pendant que vous êtes certainement libre de fournir des versions personnalisées de GetEnumerator (), MoveNext (), actuel et Reset (), il y a une façon plus simple. Comme le type de System.Array (ainsi que beaucoup d'autres classes de collection) met déjà en œuvre IEnumerable et IEnumerator, vous pouvez simplement déléguer la demande au System.Array comme suit:
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();
}
}
Une fois que vous avez mis à jour votre type de garage, vous pouvez utiliser en toute sécurité le type au sein de la construction C # foreach. En outre, étant donné que la méthode GetEnumerator () a été définie au public, l'utilisateur de l'objet peut également interagir avec le type 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);
Cependant, si vous préférez cacher la fonctionnalité de IEnumerable du niveau de l'objet, il suffit de faire utilisation de la mise en œuvre d'interface explicite:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
Ce faisant, l'utilisateur d'objet occasionnel ne trouvera pas la méthode GetEnumerator () du Garage, tandis que le foreach obtiendra l'interface en arrière-plan si nécessaire.
Adapté de la Pro C # 5.0 et Framework 4.5 .NET
Mise en œuvre IEnumerable signifie que votre classe retourne un objet IEnumerator:
public class People : IEnumerable
{
IEnumerator IEnumerable.GetEnumerator()
{
// return a PeopleEnumerator
}
}
Mise en œuvre IEnumerator signifie que votre classe retourne les méthodes et propriétés pour l'itération:
public class PeopleEnumerator : IEnumerator
{
public void Reset()...
public bool MoveNext()...
public object Current...
}
C'est la différence de toute façon.
Explication via Analogie + code Walkthrough
D'abord une explication sans code, alors je vais l'ajouter plus tard.
Disons que vous exécutez une compagnie aérienne. Et dans chaque plan que vous voulez savoir des informations sur les passagers volant dans l'avion. Fondamentalement, vous voulez être en mesure de « traverser » le plan. En d'autres termes, vous voulez être en mesure de démarrer au siège avant et de travailler ensuite votre chemin vers l'arrière de l'avion, en demandant des passagers des informations: qui ils sont, d'où ils sont, etc. Un avion ne peut faire , si elle est:
- dénombrables et
- si elle a un compteur.
Pourquoi ces exigences? Parce que ce que l'interface exige.
Si cela est la surcharge d'information, tout ce que vous devez savoir est que vous voulez être en mesure de demander à chaque passager dans le plan des questions, à partir de la première et de faire votre chemin jusqu'au dernier.
Que signifie dénombrable?
Si une compagnie aérienne est « dénombrable », cela signifie qu'il doit y avoir un agent de bord présente sur le plan, qui est seul travail est de compter - et ce agent de bord doit compter d'une manière très spécifique:
- Le compteur / agent de bord doit commencer avant le premier passager (à l'avant tout le monde où ils démo sécurité, comment mettre le gilet de sauvetage, etc.).
- Il / elle (à savoir l'agent de bord) doit « passer à côté » dans l'allée au premier siège.
- Il / elle doit alors enregistrer:. (I) la personne qui est dans le siège, et (ii) leur emplacement actuel dans l'allée
Procédures de comptage
Le capitaine de la compagnie aérienne veut un rapport sur tous les passagers au moment où ils sont examinés ou comptés. Donc, après avoir parlé à la personne dans le premier siège, le agent de bord / compteur rapporte alors au capitaine, et lorsque le rapport est donné, le compteur se souvient de son / sa position exacte dans l'allée et continue de compter là où il / elle a quitté off.
De cette manière, le capitaine est toujours en mesure d'avoir des informations sur la personne en cours à l'étude. De cette façon, s'il découvre que cette personne aime Manchester City, alors il peut donner le passager d'un traitement préférentiel, etc.
- Le compteur continue à aller jusqu'à ce qu'il arrive à la fin du plan.
Faisons cela avec la cravate IEnumerables
-
Un dénombrable est juste une collection de passagers sur un avion. La Loi sur l'aviation civile - Ce sont essentiellement les règles que tous les IEnumerables doivent suivre. Chaque fois que le préposé de la compagnie aérienne va au capitaine avec les informations de passeger, nous sommes fondamentalement «cédons du passager au capitaine. Le capitaine peut essentiellement faire ce qu'il veut avec le passager - sauf réorganisant les passagers dans l'avion. Dans ce cas, ils bénéficient d'un traitement préférentiel si elles suivent 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)
Résumé
En d'autres termes, quelque chose est dénombrable si a un compteur . Et compteur doit (essentiellement): (i) rappelle sa place ( État ), (ii) être en mesure de prochaine étape , (iii) et de savoir au sujet de la actuelle personne qu'il a affaire.
Enumerable est juste un mot de fantaisie pour « dénombrable ». En d'autres termes, un dénombrable vous permet de « Énumérer » (à savoir le nombre).
IEnumerable implémente GetEnumerator. Lorsqu'elle est appelée, cette méthode renvoie un IEnumerator qui met en œuvre MoveNext, Reset et actuel.
Ainsi, lorsque votre classe implémente IEnumerable, vous dites que vous pouvez appeler une méthode (GetEnumerator) et obtenir un nouvel objet retourné (IEnumerator) vous pouvez utiliser dans une boucle telle que foreach.
Mise en œuvre IEnumerable vous permet d'obtenir un IEnumerator pour une liste.
IEnumerator permet un accès séquentiel de style foreach aux éléments de la liste, en utilisant le mot-clé yield.
Avant la mise en œuvre de foreach (en Java 1.4, par exemple), le moyen d'itérer une liste était d'obtenir un recenseur dans la liste, puis demandez pour l'élément « suivant » dans la liste, aussi longtemps que la valeur renvoyée comme l'élément suivant est non nulle. Foreach fait simplement que implicitement comme une caractéristique de la langue, de la même façon que verrou () implémente la classe Monitor dans les coulisses.
Je me attends fonctionne foreach sur les listes, car ils mettent en œuvre IEnumerable.
- Un objet qui implémente IEnumerable permet aux autres de visiter chacun de ses éléments (par un recenseur) .
- Un objet qui implémente IEnumerator est le fait de l'itération. Il tourne en boucle sur un objet dénombrable.
Pensez des objets dénombrables comme des listes, des piles, des arbres.
IEnumerable et IEnumerator (et leurs équivalents génériques IEnumerable
IEnumerable est l'interface la plus commune que vous verriez dans la majorité du code là-bas. Elle permet la boucle foreach, générateurs (pensez rendement ) et à cause de son interface minuscule, il est utilisé pour créer des abstractions serrées. IEnumerable dépend IEnumerator.
IEnumerator , d'autre part, fournit une interface d'itération de niveau légèrement inférieur. Il est appelé le explicite iterator qui donne au programmeur plus de contrôle sur la cycle d'itération.
IEnumerable
IEnumerable est une interface standard qui permet itérer sur des collections qui le soutient (en fait, tous les types de collections que je peux penser outils aujourd'hui IEnumerable ). support du compilateur permet des fonctionnalités de langage comme foreach. En termes généraux, il permet à cette .
foreach boucle
foreach (var value in list)
Console.WriteLine(value);
Je pense que la boucle foreach est l'une des principales raisons d'utiliser IEnumerable interfaces. foreach a une syntaxe très succincte et très facile à comprendre par rapport au classique C de style pour les boucles où vous avez besoin de vérifier les différentes variables pour voir ce qu'il faisait.
donne les mots-clés
Probablement une caractéristique moins connue est que IEnumerable permet également a une inspection de code pour énumération multiple possible de IEnumerable .
IEnumerator
IEnumerator, d'autre part, est derrière l'interface scènes qui rend IEnumerble-foreach-magic travail. Au sens strict, il permet itérateurs explicites.
var iter = list.GetEnumerator();
while (iter.MoveNext())
Console.WriteLine(iter.Current);
Dans mon expérience IEnumerator est rarement utilisé dans les scénarios communs en raison de sa syntaxe plus bavard et sémantique un peu confus (au moins pour moi, par exemple MoveNext () retourne une valeur ainsi que le nom ne suggère pas du tout).
Utilisation cas pour IEnumerator
je ne IEnumerator en particulier les bibliothèques et les cadres (niveau légèrement inférieur) où je fournissais IEnumerable interfaces. Un exemple est une bibliothèque de traitement de flux de données wUEL fourni série d'objets dans une boucle de foreach même si derrière les données des scènes recueillis à l'aide de divers flux de fichiers et sérialisations.
Code client
foreach(var item in feed.GetItems())
Console.WriteLine(item);
Bibliothèque
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;
}
}
Mise en oeuvre IEnumerable signifie essentiellement que l'objet peut être itéré. Cela ne signifie pas nécessairement qu'il est un tableau comme il y a certaines listes qui ne peuvent pas être indexés mais vous pouvez les énumérer.
IEnumerator est l'objet réel utilisé pour effectuer les itérations. Il contrôle le déplacement d'un objet à l'autre dans la liste.
La plupart du temps, IEnumerable et IEnumerator sont utilisés de manière transparente dans le cadre d'une boucle de foreach.
Les différences entre IEnumerable et IEnumerator:
- IEnumerable utilise IEnumerator en interne.
- IEnumerable ne marche pas savoir quel élément / objet est en cours d'exécution.
- Chaque fois que nous passons IEnumerator à une autre fonction, il connaît la position actuelle de l'élément / objet.
-
Chaque fois que nous passons collection IEnumerable à une autre fonction, il ne connaît pas la position actuelle de l'élément / objet (ne sait pas quel élément de son exécution)
IEnumerable ont une méthode GetEnumerator ()
public interface IEnumerable<out T> : IEnumerable { IEnumerator<T> GetEnumerator(); }
IEnumerator avoir un courant de la propriété et deux méthodes Reset et MoveNext (ce qui est utile pour connaître la position actuelle d'un élément dans une liste).
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
Une bonne compréhension du motif Iterator sera utile pour vous. Je recommande la lecture de la même chose.
A un niveau élevé le modèle itérateur peut être utilisé pour fournir un moyen standard de itérer collections de tout type. Nous avons 3 participants au motif iterator, la collection réelle (client), l'agrégateur et l'itérateur. L'agrégat est une interface / classe abstraite qui a une méthode qui retourne un itérateur. Iterator est une interface / classe abstraite qui a des méthodes nous permettant de parcourir une collection.
Pour mettre en œuvre le modèle que nous devons d'abord mettre en place un itérateur pour produire un béton qui peut itérer sur la collection concernée (client) Ensuite, la collection (client) implémente l'agrégateur pour retourner une instance de l'itérateur ci-dessus.
Voici le diagramme UML
Donc, fondamentalement, en c #, IEnumerable est l'agrégat abstraite et IEnumerator est le Iterator abstrait. IEnumerable a une seule méthode GetEnumerator qui est responsable de créer une instance de IEnumerator du type désiré. Collections comme les listes mettre en œuvre le IEnumerable.
Exemple.
Laisse supposer que nous avons une getPermutations(inputString) méthode qui renvoie toutes les permutations d'une chaîne et que la méthode renvoie une instance de IEnumerable<string>
Pour compter le nombre de permutations que nous pourrions faire quelque chose comme ci-dessous.
int count = 0;
var permutations = perm.getPermutations(inputString);
foreach (string permutation in permutations)
{
count++;
}
Le compilateur C # plus ou moins convertit ci-dessus à
using (var permutationIterator = perm.getPermutations(input).GetEnumerator())
{
while (permutationIterator.MoveNext())
{
count++;
}
}
Si vous avez des questions s'il vous plaît ne pas hésiter à demander.
IEnumerable est une boîte qui contient IEnumerator. IEnumerable est l'interface de base pour toutes les collections. foreach peut fonctionner si la collection implémente IEnumerable. Dans le code ci-dessous explique l'étape d'avoir notre propre recenseur. Permet de définir d'abord notre classe dont nous allons faire la collection.
public class Customer
{
public String Name { get; set; }
public String City { get; set; }
public long Mobile { get; set; }
public double Amount { get; set; }
}
Maintenant, nous allons définir la classe qui agira comme une collection pour notre clientèle de classe. Notez qu'il met en œuvre l'interface IEnumerable. Alors que nous devons mettre en œuvre la méthode GetEnumerator. Cela renverra notre recenseur personnalisé.
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);
}
}
Maintenant, nous allons créer notre propre recenseur personnalisé comme suit. Nous avons donc à mettre en œuvre la méthode 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.
}
}
Maintenant, nous pouvons utiliser la boucle foreach sur notre collection comme ci-dessous;
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();
}
}
Une contribution mineure.
Comme beaucoup d'entre eux des explications sur « quand utiliser » et « utiliser foreach ». Je pensais d'ajouter une autre États Difference ici comme l'a demandé en question sur la différence entre les deux IEnumerable IEnumerator.
J'ai créé l'exemple de code ci-dessous sur la base des fils de discussion ci-dessous.
IEnumerable, IEnumerator vs foreach, quand utiliser ce Quelle est la différence entre les deux? IEnumerator et IEnumerable
recenseur préserve l'état (position d'itération) entre les appels de fonction en itérations d'autre part Enumerable ne fonctionne pas.
Voici l'exemple testé avec des commentaires à comprendre.
Les experts s'il vous plaît ajouter / me corriger.
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());
}
}
J'ai remarqué ces différences:
A. Nous parcourons la liste de manière différente, foreach peut être utilisé pour IEnumerable et en boucle pour IEnumerator.
B. IEnumerator peut se rappeler l'indice actuel quand on passe d'une méthode à l'autre (il commence à travailler avec index en cours), mais IEnumerable ne peut pas se rappeler l'index et réinitialiser l'index au début. Plus dans cette vidéo https://www.youtube.com/watch?v=jd3yUjGc9M0
IEnumerable et IEnumerator les deux sont des interfaces en C #.
IEnumerable est une interface définissant une seule méthode GetEnumerator() qui renvoie une interface IEnumerator.
Cela fonctionne pour un accès en lecture seule à une collection qui implémente cette IEnumerable peut être utilisé avec une instruction foreach.
IEnumerator a deux méthodes, MoveNext et Reset. Il a également une propriété appelée Current.
Ce qui suit montre la mise en œuvre de IEnumerable et 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
*/
