Die Schnittstellen IEnumerable und IEnumerator
Um den Prozess der Implementierung vorhandener .NET-Schnittstellen zu untersuchen, betrachten wir zunächst die Rolle von IEnumerable und IEnumerator. Denken Sie daran, dass C # ein Schlüsselwort mit dem Namen foreach unterstützt, mit dem Sie den Inhalt eines beliebigen Array-Typs durchlaufen können:
// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
Console.WriteLine(i);
}
Während es den Anschein haben mag, dass nur Array-Typen dieses Konstrukt verwenden können, ist die Wahrheit, dass jeder Typ, der eine Methode namens GetEnumerator () unterstützt, vom foreach-Konstrukt ausgewertet werden kann. Um dies zu veranschaulichen, folgen Sie mir!
Angenommen, wir haben eine Garage-Klasse:
// 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 ist es praktisch, die Unterelemente des Garage-Objekts mithilfe des foreach-Konstrukts zu durchlaufen, genau wie bei einem 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 Sie der Compiler darüber, dass die Garage-Klasse keine Methode namens GetEnumerator () implementiert. Diese Methode wird durch die IEnumerable-Schnittstelle formalisiert, die sich im System.Collections-Namespace befindet. Klassen oder Strukturen, die dieses Verhalten unterstützen, geben an, dass sie enthaltene Unterelemente für den Aufrufer verfügbar machen können (in diesem Beispiel das Schlüsselwort foreach selbst). Hier ist die Definition dieser Standard-.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 die GetEnumerator () -Methode einen Verweis auf eine weitere Schnittstelle mit dem Namen System.Collections.IEnumerator zurück. Diese Schnittstelle bietet die Infrastruktur, mit der der Aufrufer die im IEnumerable-kompatiblen Container enthaltenen internen Objekte durchlaufen kann:
// 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 den Garagentyp aktualisieren möchten, um diese Schnittstellen zu unterstützen, können Sie den langen Weg gehen und jede Methode manuell implementieren. Es steht Ihnen sicherlich frei, benutzerdefinierte Versionen von GetEnumerator (), MoveNext (), Current und Reset () bereitzustellen. Es gibt jedoch einen einfacheren Weg. Da der System.Array-Typ (sowie viele andere Auflistungsklassen) bereits IEnumerable und IEnumerator implementiert, können Sie die Anforderung einfach wie folgt an System.Array delegieren:
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 Ihren Garagentyp aktualisiert haben, können Sie den Typ sicher im C # foreach-Konstrukt verwenden. Da die GetEnumerator () -Methode öffentlich definiert wurde, kann der Objektbenutzer außerdem mit dem IEnumerator-Typ 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 die Funktionalität von IEnumerable auf Objektebene ausblenden möchten, verwenden Sie einfach die explizite Schnittstellenimplementierung:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
Auf diese Weise findet der Benutzer eines zufälligen Objekts die GetEnumerator () -Methode von Garage nicht, während das foreach-Konstrukt die Schnittstelle bei Bedarf im Hintergrund abruft.
Angepasst an Pro C # 5.0 und .NET 4.5 Framework
