Kann jemand IEnumerable und IEnumerator mir das erklären? [geschlossen]
https://stackoverflow.com/questions/558304
-
05-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Kann mir jemand erklären IEnumerable und IEnumerator zu mir?
zum Beispiel, wenn es über foreach zu benutzen? Was ist der Unterschied zwischen IEnumerable und IEnumerator? Warum brauchen wir es zu benutzen?
Lösung
zum Beispiel, wenn es über foreach zu benutzen?
Sie verwenden keine IEnumerable "über" foreach. IEnumerable Die Implementierung macht foreach mit möglich .
Wenn Sie schreiben Code wie:
foreach (Foo bar in baz)
{
...
}
es ist funktional äquivalent zu schreiben:
IEnumerator bat = baz.GetEnumerator();
while (bat.MoveNext())
{
bar = (Foo)bat.Current
...
}
Mit „funktionell äquivalent“ Ich meine, das ist eigentlich das, was der Compiler den Code übergeht. Sie können nicht foreach auf baz in diesem Beispiel verwenden es sei denn, baz IEnumerable implementiert.
IEnumerable bedeutet, dass baz die Methode implementiert
IEnumerator GetEnumerator()
Das IEnumerator Objekt, das diese Methode gibt die Methoden implementieren muss,
bool MoveNext()
und
Object Current()
Die erste Methode geht zum nächsten Objekt in dem IEnumerable Objekt, das das Enumerator erstellt, Rückkehr false wenn es fertig ist, und die zweiter kehrt das aktuelle Objekt.
Alles in .NET, die Sie über Geräte IEnumerable laufen können. Wenn Sie Ihre eigene Klasse erstellen, und es nicht bereits von einer Klasse erben, die IEnumerable implementiert, können Sie Ihre Klasse verwendbar in foreach Aussagen durch die Umsetzung IEnumerable (und durch eine Enumerator-Klasse zu schaffen, dass seine neue GetEnumerator Methode zurückkehren) .
Andere Tipps
Die IEnumerable und IEnumerator Schnittstellen
Zur Prüfung der Prozess der Umsetzung der bestehenden .NET-Schnittstellen beginnen, den ersten Blick lassen Sie uns auf die Rolle der IEnumerable und IEnumerator. dass C # Daran erinnern, unterstützt ein Stichwort namens foreach, die Ihnen erlaubt, iterieren den Inhalt der Array-Typ:
// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
Console.WriteLine(i);
}
Während es scheinen mag, dass nur Array-Typen Verwendung dieses Konstrukts machen, die Wahrheit der Sache ist, jede Art eine Methode namens GetEnumerator () Unterstützung durch die foreach ausgewertet werden construct.To veranschaulichen, folge mir!
Angenommen, wir eine Garage Klasse haben:
// 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);
}
}
Im Idealfall wäre es zweckmäßig sein, über die Garage des Objekts Subitems iterieren die foreach Konstrukt, wie ein Array von Datenwerten:
// 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();
}
}
Leider informiert der Compiler Sie, dass die Garage Klasse mit dem Namen kein Verfahren implementieren GetEnumerator (). Diese Methode wird von der Schnittstelle IEnumerable formalisiert, die im System.Collections-Namespace lauern. Klassen oder Strukturen, die dieses Verhalten unterstützen werben, dass sie enthielten aussetzen können Subitems den Anrufer (in diesem Beispiel ist das foreach Schlüsselwort selbst). Hier ist die Definition dieses Standards .NET-Schnittstelle:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
Wie Sie sehen können, gibt das GetEnumerator () -Methode einen Verweis auf eine weitere Schnittstelle mit dem Namen System.Collections.IEnumerator. Diese Schnittstelle stellt die Infrastruktur der Anrufer zu ermöglichen, die internen Objekte durch die IEnumerable-kompatibele Container enthalten ist, zu durchqueren:
// 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.
}
Wenn Sie die Garage Typ aktualisieren möchten diese Schnittstellen zu unterstützen, können Sie den langen Weg nehmen und jede Methode manuell implementieren. Während Sie sind sicherlich frei angepasste Versionen von bereitzustellen, GetEnumerator (), Movenext (), Strom, und Reset (), gibt es einen einfacheren Weg. Da der System.Array Typ (wie auch viele andere Sammlung Klassen) bereits IEnumerable und IEnumerator implementiert, können Sie einfach die Anfrage an den System.Array delegieren wie folgt:
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();
}
}
Nachdem Sie Ihre Garage Typ aktualisiert haben, können Sie sicher den Typ innerhalb des Konstrukts C # foreach verwenden. Weiterhin gegeben, dass der GetEnumerator () -Methode öffentlich definiert wurde, könnte das Objekt Benutzer auch mit der IEnumerator Art interagieren:
// 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);
Wenn Sie jedoch lieber die Funktionalität von IEnumerable von der Objektebene verstecken, einfach machen Verwendung von expliziter Schnittstellenimplementierung:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
Auf diese Weise die lässige Objekt Benutzer nicht die GetEnumerator () -Methode der Garage, während die foreach Konstrukt wird die Schnittstelle im Hintergrund erhalten, wenn notwendig.
Angepasst von der Pro C # 5.0 und .NET 4.5 Framework-
Implementieren von IEnumerable bedeutet, dass Ihre Klasse gibt ein IEnumerator-Objekt:
public class People : IEnumerable
{
IEnumerator IEnumerable.GetEnumerator()
{
// return a PeopleEnumerator
}
}
Implementieren von IEnumerator bedeutet, dass Ihre Klasse die Methoden und Eigenschaften für Iteration zurückgibt:
public class PeopleEnumerator : IEnumerator
{
public void Reset()...
public bool MoveNext()...
public object Current...
}
Das ist der Unterschied sowieso.
Erklärung über Analogy +-Code Lösungsweg
Zuerst wird eine Erklärung ohne Code, dann werde ich es hinzufügen, in später.
Angenommen, Sie haben eine Fluggesellschaft laufen. Und in jeder Ebene wollen Sie Informationen über die Passagiere in dem Flugzeug fliegen lernen. Im Grunde wollen Sie in der Lage sein, das Flugzeug zu „durchlaufen“. Mit anderen Worten, möchten Sie auf dem Vordersitz starten können, und dann arbeiten Sie sich in Richtung der Rückseite der Ebene, Passagiere einige Informationen zu fragen: wer sie sind, wo sie von etc. Ein Flugzeug nur das tun kann , wenn es sich um:
- zählbar, und
- , wenn es einen Zähler hat.
Warum diese Anforderungen? Denn das ist, was die Schnittstelle erfordert.
Wenn diese Informationen Überlastung ist alles, was Sie wissen müssen, ist, dass Sie jeden Passagier zu fragen, in der Ebene einige Fragen in der Lage sein wollen, ausgehend von der ersten und machen Sie Ihren Weg bis zum letzten.
Was bedeutet zählbare bedeuten?
Wenn eine Fluggesellschaft „zählbare“ ist, bedeutet dies, dass ein Flugbegleiter im Flugzeug vorhanden sein muss, die einzige Aufgabe ist, ist zu rechnen - und das Flugbegleiter in einer ganz bestimmten Art und Weise zählen muss:
- Die Zähler / Flugbegleiter vor dem ersten Passagiere beginnen muss (an der Vorderseite jedem, wo sie Sicherheit Demo, wie die Schwimmweste anziehen usw.).
- Er / sie (das heißt der Flugbegleiter) MUSS „bewegen nächste“ den Gang auf den ersten Sitz.
- Er / sie ist dann Rekord. (I), das die Person auf dem Sitz ist, und (ii) ihr aktueller Standort im Gang
Klassierung
Der Kapitän der Fluggesellschaft will einen Bericht über jeden Passagier, wie und wann sie untersucht oder gezählt. So, nachdem in den ersten Sitz in die Person, die spricht, die Flugbegleiter / Zähler meldet dann dem Kapitän, und wenn der Bericht gegeben wird, wird der Zähler erinnert sich an seine / ihre genaue Position im Gang und zählt weiter rechts, wo er / sie nach links aus.
Auf diese Weise ist der Kapitän immer in der Lage Informationen über die aktuelle Person untersucht haben. So, wenn er herausfindet, dass diese Person Manchester City will, dann kann er diesen Passagier Vorzugsbehandlung geben etc.
- Der Zähler läuft weiter, bis er das Ende der Ebene erreicht hat.
Lassen Sie sich diese Krawatte mit der IEnumerables
-
Eine zählbare ist nur eine Sammlung von Passagieren auf einer Ebene. Die Civil Aviation Law - das sind im Grunde die Regeln, die alle IEnumerables folgen müssen. Jedesmal, die Fluggesellschaft Begleiter gehen an den Kapitän mit den passeger Informationen sind wir im Grunde ‚Nachgeben‘ den Passagiers zum Kapitän. Der Kapitän kann im Grunde alles tun, was er mit dem Fahrgast will - außer auf der Ebene, die die Passagiere neu anordnen. In diesem Fall werden sie bevorzugt behandelt, wenn sie Manchester City (igitt!)
folgenforeach (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)
Zusammenfassung
Mit anderen Worten, ist etwas zählbar, wenn es einen Zähler hat . Und Zähler muss (im Wesentlichen): (i) erinnern seinen Platz ( Zustand ), (ii) der Lage sein, move nächste , (iii) und wissen über die Strom Person, die er beschäftigt sich mit.
Enumerable ist nur ein ausgefallenes Wort für „zählbar“. Mit anderen Worten, können Sie eine zählbare zu 'enumerate' (das heißt count).
IEnumerable implementiert GetEnumerator. Wenn sie aufgerufen wird, wird diese Methode eine IEnumerator welche Geräte Movenext, Reset und Strom.
Wenn also Ihre Klasse IEnumerable implementiert, Sie sagen, dass Sie eine Methode aufrufen können (GetEnumerator) und ein neues Objekt erhalten zurückgegeben (ein IEnumerator) Sie in einer Schleife wie foreach verwenden können.
Implementieren von IEnumerable ermöglicht es Ihnen, einen IEnumerator für eine Liste zu erhalten.
IEnumerator erlaubt foreach Stil sequenziellen Zugriff auf die Elemente in der Liste, um die Ausbeute Schlüsselwort.
Vor dem foreach-Implementierung (in Java 1.4, zum Beispiel), die Möglichkeit, eine Liste zu durchlaufen war einen Enumerator aus der Liste zu bekommen, dann fragen Sie nach dem „next“ Elemente in der Liste, solange der Wert zurückgegeben als nächster Artikel ist nicht null. Foreach einfach macht, dass implizit als Sprache-Funktion, in der gleichen Weise, sperren () implementiert die Monitor-Klasse hinter den Kulissen.
Ich erwarte, dass foreach auf Listen funktioniert, weil sie IEnumerable implementieren.
- Ein Objekt Implementierung IEnumerable anderen ermöglicht jedem seiner Elemente (durch einen Enumerator) zu besuchen .
- Ein Objekt Implementierung IEnumerator ist die die Iteration zu tun. Es ist Looping über ein zählbares Objekt.
Denken Sie an zählbare Objekte als von Listen, Stacks, Bäume.
IEnumerable und IEnumerator (und ihre generischen Pendants IEnumerable
IEnumerable ist die häufigste Schnittstelle Sie dort in der Mehrheit des Codes sehen würde. Es ermöglicht die foreach-Schleife, die Generatoren (man denke Ertrag ) und wegen seiner winzigen Schnittstelle, wird es verwendet, um enge Abstraktionen zu erstellen. IEnumerable hängt von IEnumerator .
IEnumerator , auf der anderen Seite, bietet eine etwas geringere Iteration Schnittstelle. Es wird bezeichnet als die rel="noreferrer">, die dem Programmierer mehr Kontrolle über das gibt Iterationszyklus.
IEnumerable
IEnumerable eine Standardschnittstelle ist die Iteration über Sammlungen ermöglicht, die es unterstützt (in der Tat, alles was ich Sammlung Arten von heute Geräte denken IEnumerable ). Compiler-Unterstützung ermöglicht Sprachfunktionen wie foreach. Allgemein ausgedrückt ermöglicht es dieses implizite Iterator Implementierung .
foreach Schleife
foreach (var value in list)
Console.WriteLine(value);
Ich denke, foreach Schleife einer der Hauptgründe ist für die Verwendung von IEnumerable Schnittstellen. foreach hat eine sehr prägnante Syntax und sehr einfach zu klassisch im Vergleich zu verstehen C Stil für Schleifen, wo Sie die verschiedenen Variablen überprüfen müssen, um zu sehen, was es tat.
Keyword Ausbeute
Wahrscheinlich ein weniger bekanntes Merkmal ist, dass IEnumerable kann auch hat eine Code-Inspektion für Mögliche mehrere Auszählung von IEnumerable .
IEnumerator
IEnumerator, auf der anderen Seite ist die hinter den Kulissen-Schnittstelle, die machen IEnumerble-foreach-magic Arbeit. Streng genommen, es ermöglicht explizite Iteratoren.
var iter = list.GetEnumerator();
while (iter.MoveNext())
Console.WriteLine(iter.Current);
Nach meiner Erfahrung IEnumerator ist selten gemeinsam Szenarien aufgrund seiner ausführlicheren Syntax und etwas verwirrend Semantik (zumindest für mich eingesetzt, zB Movenext () gibt einen Wert als auch, was der Name gar nicht vorschlagen).
Use Case für IEnumerator
ich nur verwendet IEnumerator insbesondere (etwas niedrigeres Niveau) Bibliotheken und Frameworks, wo ich zur Verfügung stelle IEnumerable Schnittstellen. Ein Beispiel ist eine Datenstrom-Verarbeitungsbibliothek which bereitgestellt Reihe von Objekten in einer foreach Schleife, obwohl hinter den Kulissen Daten wurden verschiedene Dateiströme und periodische Veröffentlichungen gesammelt werden.
Client-Code
foreach(var item in feed.GetItems())
Console.WriteLine(item);
Bibliothek
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;
}
}
Die Implementierung IEnumerable bedeutet im Wesentlichen, dass das Objekt iteriert werden kann. Dies bedeutet nicht unbedingt, es ist ein Array, da es bestimmte Listen, die nicht indiziert werden können, aber Sie können sie aufzuzählen.
IEnumerator ist das eigentliche Objekt verwendet, um die Iterationen durchzuführen. Er steuert von einem Objekt zum nächsten in der Liste zu bewegen.
Die meiste Zeit, IEnumerable & IEnumerator transparent als Teil einer foreach Schleife verwendet wird.
Die Unterschiede zwischen IEnumerable und IEnumerator:
- IEnumerable verwendet IEnumerator intern.
- IEnumerable doesnt wissen, welches Element / Objekt ausgeführt wird.
- Jedes Mal, wenn wir IEnumerator an eine andere Funktion übergeben, kennt er die aktuelle Position von Punkt / Objekt.
-
Wenn wir passieren IEnumerable Sammlung an eine andere Funktion, es nicht die aktuelle Position des Artikel / Objekt kennen (weiß nicht, welches Element seiner Ausführung)
IEnumerable hat eine Methode GetEnumerator ()
public interface IEnumerable<out T> : IEnumerable { IEnumerator<T> GetEnumerator(); }
IEnumerator hat einen Objektstrom und zwei Methoden Reset und Movenext.
(die für die Kenntnis der aktuelle Position eines Elements in einer Liste nützlich ist)public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
Ein Verständnis der Iterator Muster wird für Sie hilfreich sein. Ich empfehle das gleiche zu lesen.
Auf einem hohen Niveau kann das Iterator-Muster verwendet werden, eine Standardmethode zur Verfügung zu stellen Laufens durch Sammlungen jeglicher Art. Wir haben 3 Teilnehmer der Iterator-Muster, die tatsächliche Sammlung (Client), der Aggregator und der Iterator. Das Aggregat ist eine Schnittstelle / abstrakte Klasse, die eine Methode, die einen Iterator zurückgibt. Iterator ist eine Schnittstelle / abstrakte Klasse, die Methoden hat es uns ermöglicht, durch eine Sammlung zu iterieren.
Um das Muster zu implementieren wir zunächst einen Iterator implementieren müssen, um einen Beton zu erzeugen, die über die betreffende Sammlung laufen können (Client) Dann wird die Sammlung (Client) implementiert den Aggregator eine Instanz des oben Iterator zurück.
Hier ist das UML-Diagramm
Also im Grunde in c #, IEnumerable ist das abstrakte Aggregat und IEnumerator ist die abstrakte Iterator. IEnumerable hat eine einzige Methode GetEnumerator, die zum Erstellen einer Instanz von IEnumerator des gewünschten Typs verantwortlich ist. Sammlungen wie Listen implementieren die IEnumerable.
Beispiel.
Lets nehme an, dass wir eine Methode getPermutations(inputString) haben, die alle Permutationen einer Zeichenkette zurückgibt und dass die Methode gibt eine Instanz von IEnumerable<string>
Um die Anzahl von Permutationen zählen wir so etwas wie die unten tun könnten.
int count = 0;
var permutations = perm.getPermutations(inputString);
foreach (string permutation in permutations)
{
count++;
}
Der C # -Compiler mehr oder weniger konvertiert die oben
using (var permutationIterator = perm.getPermutations(input).GetEnumerator())
{
while (permutationIterator.MoveNext())
{
count++;
}
}
Wenn Sie Fragen haben, zögern Sie bitte nicht zu fragen.
IEnumerable ist eine Box, die IEnumerator enthält. IEnumerable ist Basis-Interface für alle Kollektionen. foreach Schleife arbeiten kann, wenn die Sammlung IEnumerable implementiert. Im folgenden Code erklärt es den Schritt des eigenen Enumerator hat. Lets definiert zuerst unsere Klasse, von denen wir die Sammlung machen sind.
public class Customer
{
public String Name { get; set; }
public String City { get; set; }
public long Mobile { get; set; }
public double Amount { get; set; }
}
Jetzt definieren wir die Klasse, die als eine Sammlung für unsere Klasse Kunden handeln. Beachten Sie, dass es die Schnittstelle IEnumerable implementiert. Damit wir haben die Methode GetEnumerator zu implementieren. Dies wird unsere eigene Enumerator zurück.
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);
}
}
Jetzt werden wir unsere eigene Enumerator wie folgt erstellen. So müssen wir Methode Movenext implementieren.
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.
}
}
Jetzt können wir foreach Schleife über unsere Sammlung wie unten verwenden;
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();
}
}
ein geringer Beitrag.
Wie viele von ihnen erklären zu ‚verwenden, wenn‘ und ‚mit foreach verwenden‘. Ich dachte an das Hinzufügen eines weiteren Staaten Difference hier in Frage über den Unterschied zwischen den beiden IEnumerable ein IEnumerator angefordert.
habe ich das folgende Codebeispiel auf der Grundlage der folgenden Diskussion Threads.
IEnumerable, IEnumerator vs foreach, wenn zu verwenden, was Was ist der Unterschied zwischen IEnumerator und IEnumerable?
Enumerator bewahrt die Zustand (Iteration Position) zwischen Funktionsaufrufen während Iterationen der anderen Hand Enumerable nicht.
Hier ist das getestete Beispiel mit Kommentaren zu verstehen.
Experten fügen Sie / korrigieren Sie mich.
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());
}
}
Ich habe diese Unterschiede bemerkt:
A. Wir wiederholen die Liste in verschiedener Weise kann foreach für IEnumerable verwendet werden und while-Schleife für IEnumerator.
B. IEnumerator kann den aktuellen Index erinnern, wenn wir von einer Methode zur anderen wechseln (es beginnen mit aktuellen Index arbeiten), aber IEnumerable kann den Index nicht mehr erinnern und es den Index zu Anfang zurückgesetzt. Mehr in diesem Video https://www.youtube.com/watch?v=jd3yUjGc9M0
IEnumerable und IEnumerator beiden Schnittstellen in C #.
IEnumerable ist eine Schnittstelle eine einzelne Methode GetEnumerator() definiert, die eine Schnittstelle IEnumerator zurückgibt.
Dies funktioniert für Nur-Lese-Zugriff auf eine Sammlung, die die IEnumerable implementiert, kann mit einer foreach Anweisung verwendet werden.
IEnumerator hat zwei Methoden, MoveNext und Reset. Es hat auch eine Eigenschaft namens Current.
Im Folgenden wird die Implementierung von IEnumerable und 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
*/
