Quelqu'un peut-il m'expliquer IEnumerable et IEnumerator?
Quelqu'un peut-il m'expliquer IEnumerable et IEnumerator?
par exemple, quand l'utiliser sur foreach? Quelle est la différence entre IEnumerable et IEnumerator? Pourquoi avons-nous besoin de l'utiliser?
par exemple, quand l'utiliser sur foreach?
Vous n'utilisez pas IEnumerable "au dessus de" foreach. L'implémentation de IEnumerable permet d'utiliser foreach possible .
Quand vous écrivez un code comme:
foreach (Foo bar in baz)
{
...
}
cela équivaut fonctionnellement à écrire:
IEnumerator bat = baz.GetEnumerator();
while (bat.MoveNext())
{
bar = (Foo)bat.Current
...
}
Par "fonctionnellement équivalent", je veux dire que le compilateur transforme le code en ce sens Vous ne pouvez pas utiliser foreach sur baz dans cet exemple sauf si baz implémente IEnumerable.
IEnumerable signifie que baz implémente la méthode
IEnumerator GetEnumerator()
L'objet IEnumerator que cette méthode retourne doit implémenter les méthodes
bool MoveNext()
et
Object Current()
La première méthode passe à l'objet suivant dans l'objet IEnumerable qui a créé l'énumérateur, en retournant false si c'est fait, et la seconde renvoie l'objet en cours.
Tout ce que vous pouvez parcourir en .Net implémente IEnumerable. Si vous construisez votre propre classe et qu'elle n'hérite pas déjà d'une classe qui implémente IEnumerable, vous pouvez la rendre utilisable dans les instructions foreach en implémentant IEnumerable (et en créant une classe enumérateur que sa nouvelle méthode GetEnumerator retournera) .
Les interfaces IEnumerable et IEnumerator
Pour commencer à examiner le processus de mise en œuvre des interfaces .NET existantes, examinons d’abord le rôle de IEnumerable et IEnumerator. Rappelez-vous que C # prend en charge un mot clé nommé foreach qui vous permet d'effectuer une itération sur le contenu de tout type de tableau:
// 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 tableau puissent utiliser cette construction, la vérité est que, tout type prenant en charge une méthode nommée GetEnumerator () peut être évalué par la construction foreach.To .__ illustre, suivez-moi!
Supposons que nous ayons une classe de 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 pratique de parcourir les sous-éléments de l’objet Garage à l’aide de la construction foreach , 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 n'implémente pas une méthode nommée GetEnumerator (). Cette méthode est formalisée par l'interface IEnumerable, qui se cache dans l'espace de noms System.Collections . Les classes ou les structures qui prennent en charge ce problème annoncent qu'elles peuvent exposer les sous-éléments Contenus à l'appelant (dans cet exemple, le mot-clé foreach lui-même). Voici la définition de cette interface standard .NET:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
Comme vous pouvez le constater, la méthode GetEnumerator () renvoie une référence à une autre interface encore nommée System.Collections.IEnumerator. Cette interface fournit l'infrastructure permettant à l'appelant de traverser les objets internes contenus dans le conteneur 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 vous souhaitez mettre à jour le type de garage pour prendre en charge ces interfaces, vous pouvez prendre le chemin le plus long et implémenter chaque méthode manuellement. Bien que vous soyez certainement libre de fournir des versions personnalisées de GetEnumerator (), MoveNext (), Current et Reset (), il existe un moyen plus simple. Comme le type System.Array (ainsi que de nombreuses autres classes de collection) implémente déjà IEnumerable et IEnumerator, vous pouvez simplement déléguer la demande à 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();
}
}
Après avoir mis à jour votre type de garage, vous pouvez utiliser le type en toute sécurité dans la construction C # pour chaque. De plus, étant donné que la méthode GetEnumerator () a été définie publiquement, 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 masquer la fonctionnalité de IEnumerable au niveau objet, utilisez simplement Use de la mise en œuvre d'interface explicite:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
Ainsi, l’utilisateur d'objet occasionnel ne trouvera pas la méthode GetEnumerator () de Garage, tandis que la construction Foreach obtiendra l'interface en arrière-plan si nécessaire.
Adapté du Pro C # 5.0 et du .NET 4.5 Framework
Implémenter IEnumerable signifie que votre classe retourne un objet IEnumerator:
public class People : IEnumerable
{
IEnumerator IEnumerable.GetEnumerator()
{
// return a PeopleEnumerator
}
}
L'implémentation d'IEnumerator signifie que votre classe retourne les méthodes et les 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 quand même.
Explication via Analogie + Code Procédure pas à pas
D'abord une explication sans code, ensuite je l'ajouterai plus tard.
Disons que vous dirigez une compagnie aérienne. Et dans chaque avion, vous voulez avoir des informations sur les passagers qui volent dans l'avion. En gros, vous voulez pouvoir "traverser" l'avion. En d’autres termes, vous voulez pouvoir commencer par le siège avant, puis vous diriger vers l’arrière de l’avion, en demandant aux passagers des informations: qui sont-ils, d’où ils viennent, etc. Un avion ne peut le faire que , Si c'est:
- comptable, et
- s'il y a un compteur.
Pourquoi ces exigences? Parce que c'est ce que l'interface nécessite.
S'il s'agit d'une surcharge d'informations, tout ce que vous devez savoir, c'est que vous voulez pouvoir poser des questions à chaque passager dans l'avion, en commençant par la première et en passant à la dernière.
Que signifie dénombrable?
Si une compagnie aérienne est "comptable", cela signifie qu'il DOIT y avoir un agent de bord présent dans l'avion. Le seul travail de celui-ci est de compter - et cet agent de bord DOIT compter de manière très spécifique:
- Le comptoir/hôtesse de l'air DOIT commencer avant le premier passager (devant chacun des participants où ils démontrent la sécurité, comment mettre le gilet de sauvetage, etc.).
- Il/elle (c'est-à-dire l'agent de bord) DOIT "se déplacer ensuite" dans l'allée jusqu'au premier siège.
- Il doit ensuite enregistrer: (i) la personne qui occupe le siège et (ii) son emplacement actuel dans le couloir.
Procédures de comptage
Le capitaine de la compagnie aérienne veut un rapport sur chaque passager au fur et à mesure de leur enquête ou de leur comptabilisation. Donc, après avoir parlé à la personne au premier siège, l’agent de bord/compteur se présente au commandant de bord et, lorsque le compte rendu est donné, le compteur se souvient de sa position exacte dans l’allée et continue de compter à la place de son départ. de.
De cette manière, le capitaine peut toujours avoir des informations sur la personne actuellement enquêtée. Ainsi, s’il découvre que cet individu aime Manchester City, il pourra alors accorder à ce passager un traitement préférentiel, etc.
- Le compteur continue jusqu'à ce qu'il atteigne la fin de l'avion.
Cravate cela avec les IEnumerables
Un énumérable est juste une collection de passagers dans un avion. La loi sur l'aviation civile - ce sont essentiellement les règles que tous les IEnumerables doivent respecter. Chaque fois que l'agent de bord présente des informations au passager auprès du commandant de bord, nous «cédons» le passager au commandant de bord. Le commandant de bord peut faire ce qu’il veut avec le passager - sauf en réarrangeant les passagers dans l’avion. Dans ce cas, ils bénéficient d’un traitement préférentiel s’ils 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 comptable si elle a un compteur. Et le compteur doit (en gros): (i) se rappeler sa place (state), (ii) être capable de se déplacer ensuite, (iii) et connaître la personne actuelle à qui il a affaire avec.
Enumerable est juste un mot de fantaisie pour "dénombrable". En d’autres termes, un énumérable vous permet d’énumérer (c’est-à-dire compter).
IEnumerable implémente GetEnumerator. Lorsqu'elle est appelée, cette méthode retourne un IEnumerator qui implémente MoveNext, Reset et Current.
Ainsi, lorsque votre classe implémente IEnumerable, vous dites que vous pouvez appeler une méthode (GetEnumerator) et obtenir un nouvel objet renvoyé (un IEnumerator), que vous pouvez utiliser dans une boucle telle que foreach.
L'implémentation d'IEnumerable vous permet d'obtenir un IEnumerator pour une liste.
IEnumerator permet un accès séquentiel par style aux éléments de la liste, à l’aide du mot-clé rendement.
Avant l'implémentation foreach (en Java 1.4, par exemple), le moyen d'itérer une liste consistait à extraire un énumérateur de la liste, puis à lui demander l'élément "suivant" dans la liste, aussi longtemps que la valeur renvoyée le prochain l'article n'est pas nul. Foreach fait simplement cela implicitement en tant que fonctionnalité de langage, de la même manière que lock () implémente la classe Monitor en arrière-plan.
Je m'attends à ce que foreach travaille sur les listes car elles implémentent IEnumerable.
- Un objet implémentant IEnumerable permet aux autres de visiter chacun de ses éléments (par un énumérateur).
- Un objet implémentant IEnumerator est l'itération en cours. Il boucle sur un objet énumérable.
Pensez aux objets énumérables comme aux listes, aux piles, aux arbres.
IEnumerable et IEnumerator (et leurs équivalents génériques IEnumerable <T> et IEnumerator <T>) sont des interfaces de base de itérateur implémentations dans collections de bibliothèques de classes .Net Framework .
IEnumerable est l'interface la plus courante que vous verriez dans la majorité du code. Il active la boucle foreach, les générateurs (think yield) et, en raison de sa petite interface, permet de créer des abstractions serrées. IEnumerable dépend de IEnumerator .
IEnumerator, d’autre part, fournit une interface d’itération de niveau légèrement inférieure. C'est ce qu'on appelle le itérateur explicite qui donne au programmeur plus de contrôle sur le cycle d'itération.
IEnumerable
IEnumerable est une interface standard qui permet de parcourir des collections qui la prennent en charge (en fait, tous les types de collection auxquels je peux penser aujourd'hui implémentent IEnumerable). La prise en charge du compilateur autorise des fonctionnalités linguistiques telles que foreach. En termes généraux, cela active cette implémentation d'itérateur implicite .
foreach Loop
foreach (var value in list)
Console.WriteLine(value);
Je pense que la boucle foreach est l’une des principales raisons d’utiliser les interfaces IEnumerable. foreach a une syntaxe très succincte et très facile à comprendre par rapport au style classique C pour les boucles où vous devez vérifier les différentes variables pour voir ce qu’il fait.
rendement
Une caractéristique moins connue est que IEnumerable active également générateurs en C # avec l'utilisation d'instructions yield return et yield break.
IEnumerable<Thing> GetThings() {
if (isNotReady) yield break;
while (thereIsMore)
yield return GetOneMoreThing();
}
Les abstractions
Un autre scénario courant consiste à utiliser IEnumerable pour fournir des abstractions minimalistes. Comme il s'agit d'une interface minuscule et en lecture seule, nous vous invitons à exposer vos collections sous la forme IEnumerable (plutôt que List par exemple). De cette façon, vous êtes libre de modifier votre implémentation sans altérer le code de votre client (par exemple, modifiez List en un LinkedList).
Je t'ai eu
Un comportement à prendre en compte est que, dans les implémentations en continu (par exemple, en récupérant d’abord une ligne de données dans une base de données, au lieu de charger tous les résultats en mémoire), vous ne pouvez pas parcourir la collection plus d’une fois. Cela contraste avec les collections en mémoire telles que List, dans lesquelles vous pouvez effectuer plusieurs itérations sans problème. ReSharper, par exemple, a une inspection de code pour Énumération multiple possible de IEnumerable .
IEnumerator
IEnumerator, en revanche, est l’interface qui permet de faire fonctionner IEnumerble-foreach-magic. Strictement parlant, cela permet des itérateurs explicites.
var iter = list.GetEnumerator();
while (iter.MoveNext())
Console.WriteLine(iter.Current);
D'après mon expérience, IEnumerator est rarement utilisé dans les scénarios courants en raison de sa syntaxe plus détaillée et de la sémantique légèrement déroutante (du moins pour moi; par exemple, MoveNext () renvoie également une valeur, ce que le nom ne suggérer du tout).
Cas d'utilisation pour IEnumerator
J'utilisais uniquement IEnumerator dans des bibliothèques et des structures particulières (niveau légèrement inférieur) où je fournissais des interfaces IEnumerable. Un exemple est une bibliothèque de traitement de flux de données qui fournissait une série d'objets dans une boucle foreach même si les données en coulisse étaient collectées à 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;
}
}
L'implémentation de IEnumerable signifie essentiellement que l'objet peut être itéré. Cela ne signifie pas nécessairement qu'il s'agit d'un tableau car certaines listes ne peuvent pas être indexées, mais vous pouvez les énumérer.
IEnumerator est l'objet 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 & IEnumerator sont utilisés de manière transparente dans le cadre d'une boucle foreach.
Différences entre IEnumerable et IEnumerator:
- IEnumerable utilise IEnumerator en interne.
- IEnumerable ne sait pas 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/de l'objet.
Chaque fois que nous transmettons la collection IEnumerable à une autre fonction, il ne connaît pas la position actuelle de l'élément/objet (il ne sait pas quel élément est en cours d'exécution)
IEnumerable a une méthode GetEnumerator ()
public interface IEnumerable<out T> : IEnumerable { IEnumerator<T> GetEnumerator(); }
IEnumerator a une propriété current et deux méthodes Reset et MoveNext (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 compréhension du modèle d'Iterator vous sera utile. Je recommande de lire la même chose.
À un niveau élevé, le modèle d'itérateur peut être utilisé pour fournir un moyen standard d'itération à travers des collections de tout type. Nous avons 3 participants dans le modèle d'itérateur, la collection réelle (client), l'agrégateur et l'itérateur. L'agrégat est une classe abstraite d'interface/qui a une méthode qui retourne un itérateur. Iterator est une classe d'interface/abstraite dotée de méthodes nous permettant de parcourir une collection.
Pour implémenter le modèle, nous devons d’abord implémenter un itérateur afin de produire un concret pouvant itérer sur la collection concernée (client) Ensuite, la collection (client) implémente l’agrégateur pour renvoyer une instance de l’itérateur ci-dessus.
Voici le diagramme UML 
Donc, fondamentalement, dans c #, IEnumerable est l’agrégat abstrait et IEnumerator est l’itérateur abstrait. IEnumerable a une méthode unique GetEnumerator qui est responsable de la création d'une instance d'IEnumerator du type souhaité. Les collections telles que les listes implémentent IEnumerable.
Exemple . Supposons que nous ayons une méthode getPermutations(inputString) qui retourne toutes les permutations d’une chaîne et que la méthode retourne une instance de IEnumerable<string>
Afin de compter le nombre de permutations, 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 # convertit plus ou moins ce qui précède en
using (var permutationIterator = perm.getPermutations(input).GetEnumerator())
{
while (permutationIterator.MoveNext())
{
count++;
}
}
Si vous avez des questions s'il vous plaît n'hésitez pas à demander.
IEnumerable est une boîte contenant Ienumerator. IEnumerable est l'interface de base pour toutes les collections. Les boucles foreach peuvent fonctionner si la collection implémente IEnumerable. Dans le code ci-dessous, il explique l’étape consistant à avoir notre propre énumérateur. Commençons par définir 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; }
}
Nous allons maintenant définir la classe qui agira comme une collection pour notre classe client. Notez qu'il implémente l'interface IEnumerable. Nous devons donc implémenter la méthode GetEnumerator. Cela renverra notre énumérateur 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);
}
}
Nous allons maintenant créer notre propre énumérateur, comme suit. Donc, nous devons implémenter 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.
}
}
Nous pouvons maintenant 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 nous expliquent «quand utiliser» et «utiliser avec foreach '..____, j’ai pensé ajouter ici une autre différence States comme demandé en question sur la différence entre IEnumerable et IEnumerator.
J'ai créé l'exemple de code ci-dessous en fonction des discussions ci-dessous.
IEnumerable, IEnumerator vs foreach, quand utiliser quoiQuelle est la différence entre IEnumerator et IEnumerable?
L'énumérateur conserve l'état (position d'itération) entre les appels de fonction, tandis que l'itération n'est pas inversée.
Voici l'exemple testé avec des commentaires à comprendre.
Experts s'il vous plaît ajoutez/corrigez-moi.
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 itérons la liste de différentes manières, foreach peut être utilisé pour IEnumerable et while loop pour IEnumerator.
B. IEnumerator peut se souvenir de l'index actuel lorsque nous passons d'une méthode à une autre (il commence à travailler avec l'index actuel) mais IEnumerable ne se souvient pas de l'index et le réinitialise à son début. Plus dans cette vidéo https://www.youtube.com/watch?v=jd3yUjGc9M0
IEnumerable et IEnumerator sont des interfaces en C #.
IEnumerable est une interface définissant une méthode unique GetEnumerator() qui renvoie une interface IEnumerator.
Cela fonctionne pour l'accès en lecture seule à une collection qui implémente que IEnumerable peut être utilisé avec une instruction foreach.
IEnumerator a deux méthodes, MoveNext et Reset. Il possède également une propriété appelée Current.
Ce qui suit montre l'implémentation 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
*/