Auflistungen (C#)Collections (C#)

Für eine Vielzahl von Anwendungen sollten Sie Gruppen von miteinander verwandten Objekten erstellen und verwalten.For many applications, you want to create and manage groups of related objects. Zum Gruppieren von Objekten gibt es zwei Möglichkeiten: das Erstellen von Objektarrays und das Erstellen von Auflistungen von Objekten.There are two ways to group objects: by creating arrays of objects, and by creating collections of objects.

Arrays am besten zum Erstellen und Arbeiten mit einer festen Anzahl von Objekten mit starkem Typ geeignet.Arrays are most useful for creating and working with a fixed number of strongly-typed objects. Weitere Informationen zu Arrays finden Sie unter Arrays.For information about arrays, see Arrays.

Auflistungen ermöglichen ein flexibleres Arbeiten mit Objektgruppen.Collections provide a more flexible way to work with groups of objects. Im Gegensatz zu Arrays kann sich die Gruppe von Objekten, mit denen Sie arbeiten, in Abhängigkeit von den sich ändernden Anforderungen der Anwendung dynamisch vergrößern bzw. verkleinern.Unlike arrays, the group of objects you work with can grow and shrink dynamically as the needs of the application change. Bei einigen Auflistungen können Sie jedem Objekt, das Sie in die Auflistung einfügen, einen Schlüssel zuweisen, sodass das Objekt anhand des Schlüssels schnell abgerufen werden kann.For some collections, you can assign a key to any object that you put into the collection so that you can quickly retrieve the object by using the key.

Eine Auflistung ist eine Klasse. Daher müssen Sie eine Instanzen der Klasse deklarieren, bevor Sie dieser Auflistung Elemente hinzufügen können.A collection is a class, so you must declare an instance of the class before you can add elements to that collection.

Wenn die Auflistung Elemente eines Datentyps enthält, können Sie eine der Klassen im System.Collections.Generic-Namespace verwenden.If your collection contains elements of only one data type, you can use one of the classes in the System.Collections.Generic namespace. Eine generische Auflistung erzwingt Typsicherheit, sodass der Auflistung kein anderer Datentyp hinzugefügt werden kann.A generic collection enforces type safety so that no other data type can be added to it. Wenn Sie ein Element aus einer generischen Auflistung abrufen, brauchen Sie dessen Datentyp nicht zu bestimmen oder zu konvertieren.When you retrieve an element from a generic collection, you do not have to determine its data type or convert it.

Hinweis

Schließen Sie bei den Beispielen in diesem Thema using-Anweisungen für die System.Collections.Generic- und System.Linq-Namespaces ein.For the examples in this topic, include using directives for the System.Collections.Generic and System.Linq namespaces.

InhaltIn this topic

Verwenden einer einfachen AuflistungUsing a Simple Collection

In den Beispielen in diesem Abschnitt wird die generische Klasse List<T> verwendet, die es Ihnen ermöglicht, mit einer stark typisierten Liste von Objekten zu arbeiten.The examples in this section use the generic List<T> class, which enables you to work with a strongly typed list of objects.

Das folgende Beispiel erstellt eine Liste von Zeichenfolgen und durchläuft die Zeichenfolgen unter Verwendung einer foreach-Anweisung.The following example creates a list of strings and then iterates through the strings by using a or foreach statement.

// Create a list of strings.  
var salmons = new List<string>();  
salmons.Add("chinook");  
salmons.Add("coho");  
salmons.Add("pink");  
salmons.Add("sockeye");  

// Iterate through the list.  
foreach (var salmon in salmons)  
{  
    Console.Write(salmon + " ");  
}  
// Output: chinook coho pink sockeye  

Wenn der Inhalt einer Auflistung im Voraus bekannt ist, können Sie einen Auflistungsinitialisierer verwenden, um die Auflistung zu initialisieren.If the contents of a collection are known in advance, you can use a collection initializer to initialize the collection. Weitere Informationen finden Sie unter Objekt- und Auflistungsinitialisierer.For more information, see Object and Collection Initializers.

Das folgende Beispiel entspricht dem vorherigen Beispiel, außer dass ein Auflistungsinitialisierer verwendet wird, um der Auflistung Elemente hinzuzufügen.The following example is the same as the previous example, except a collection initializer is used to add elements to the collection.

// Create a list of strings by using a  
// collection initializer.  
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };  

// Iterate through the list.  
foreach (var salmon in salmons)  
{  
    Console.Write(salmon + " ");  
}  
// Output: chinook coho pink sockeye  

Sie können anstelle einer for-Anweisung eine foreach-Anweisung verwenden, um eine Auflistung zu durchlaufen.You can use a for statement instead of a foreach statement to iterate through a collection. Sie erreichen dies, indem Sie durch die Indexposition auf die Auflistungselemente zugreifen.You accomplish this by accessing the collection elements by the index position. Der Index der Elemente beginnt mit 0 und endet an der Elementanzahl minus 1.The index of the elements starts at 0 and ends at the element count minus 1.

Im folgenden Beispiel werden die Elemente einer Auflistung unter Verwendung von for anstelle von foreach durchlaufen.The following example iterates through the elements of a collection by using for instead of foreach.

// Create a list of strings by using a  
// collection initializer.  
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };  

for (var index = 0; index < salmons.Count; index++)  
{  
    Console.Write(salmons[index] + " ");  
}  
// Output: chinook coho pink sockeye  

Im folgenden Beispiel wird ein Element aus der Auflistung entfernt, indem das zu entfernende Objekt angegeben wird.The following example removes an element from the collection by specifying the object to remove.

// Create a list of strings by using a  
// collection initializer.  
var salmons = new List<string> { "chinook", "coho", "pink", "sockeye" };  

// Remove an element from the list by specifying  
// the object.  
salmons.Remove("coho");  

// Iterate through the list.  
foreach (var salmon in salmons)  
{  
    Console.Write(salmon + " ");  
}  
// Output: chinook pink sockeye  

Im folgenden Beispiel werden alle Elemente aus einer generischen Liste entfernt.The following example removes elements from a generic list. Anstelle einer foreach-Anweisung wird eine for-Anweisung verwendet, die die Elemente in absteigender Reihenfolge durchläuft.Instead of a foreach statement, a for statement that iterates in descending order is used. Dies liegt daran, dass die RemoveAt-Methode dazu führt, dass Elemente nach einem entfernten Element einen niedrigeren Indexwert haben.This is because the RemoveAt method causes elements after a removed element to have a lower index value.

var numbers = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };  

// Remove odd numbers.  
for (var index = numbers.Count - 1; index >= 0; index--)  
{  
    if (numbers[index] % 2 == 1)  
    {  
        // Remove the element by specifying  
        // the zero-based index in the list.  
        numbers.RemoveAt(index);  
    }  
}  

// Iterate through the list.  
// A lambda expression is placed in the ForEach method  
// of the List(T) object.  
numbers.ForEach(  
    number => Console.Write(number + " "));  
// Output: 0 2 4 6 8  

Für den Typ der Elemente in List<T> können Sie auch eine eigene Klasse definieren.For the type of elements in the List<T>, you can also define your own class. Im folgenden Beispiel wird die Galaxy-Klasse, die von List<T> verwendet wird, im Code definiert.In the following example, the Galaxy class that is used by the List<T> is defined in the code.

private static void IterateThroughList()  
{  
    var theGalaxies = new List<Galaxy>  
        {  
            new Galaxy() { Name="Tadpole", MegaLightYears=400},  
            new Galaxy() { Name="Pinwheel", MegaLightYears=25},  
            new Galaxy() { Name="Milky Way", MegaLightYears=0},  
            new Galaxy() { Name="Andromeda", MegaLightYears=3}  
        };  

    foreach (Galaxy theGalaxy in theGalaxies)  
    {  
        Console.WriteLine(theGalaxy.Name + "  " + theGalaxy.MegaLightYears);  
    }  

    // Output:  
    //  Tadpole  400  
    //  Pinwheel  25  
    //  Milky Way  0  
    //  Andromeda  3  
}  

public class Galaxy  
{  
    public string Name { get; set; }  
    public int MegaLightYears { get; set; }  
}  

Arten von AuflistungenKinds of Collections

Viele allgemeine Auflistungen werden von .NET Framework bereitgestellt.Many common collections are provided by the .NET Framework. Jeder Auflistungstyp ist für einen speziellen Zweck ausgelegt.Each type of collection is designed for a specific purpose.

Einige der häufig verwendeten Auflistungsklassen werden in diesem Abschnitt beschrieben:Some of the common collection classes are described in this section:

System.Collections.Generic-KlassenSystem.Collections.Generic Classes

Zum Erstellen einer generischen Auflistung verwenden Sie eine der Klassen im System.Collections.Generic-Namespace.You can create a generic collection by using one of the classes in the System.Collections.Generic namespace. Eine generische Auflistung ist sinnvoll, wenn jedes Element der Auflistung zum gleichen Datentyp gehört.A generic collection is useful when every item in the collection has the same data type. Eine generische Auflistung erzwingt eine starke Typisierung, da ihr nur Elemente des gewünschten Datentyps hinzugefügt werden können.A generic collection enforces strong typing by allowing only the desired data type to be added.

In der folgenden Tabelle werden einige der häufig verwendeten Klassen des System.Collections.Generic-Namespace aufgelistet:The following table lists some of the frequently used classes of the System.Collections.Generic namespace:

KlasseClass BeschreibungDescription
Dictionary<TKey,TValue> Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, deren Reihenfolge anhand des Schlüssels bestimmt wird.Represents a collection of key/value pairs that are organized based on the key.
List<T> Stellt eine Liste von Objekten dar, auf die über einen Index zugegriffen werden kann.Represents a list of objects that can be accessed by index. Stellt Methoden zum Durchsuchen, Sortieren und Bearbeiten von Listen bereit.Provides methods to search, sort, and modify lists.
Queue<T> Stellt eine FIFO-Auflistung (First In, First Out) von Objekten dar.Represents a first in, first out (FIFO) collection of objects.
SortedList<TKey,TValue> Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die auf Grundlage der zugeordneten IComparer<T>-Implementierung nach den Schlüsseln sortiert sind.Represents a collection of key/value pairs that are sorted by key based on the associated IComparer<T> implementation.
Stack<T> Stellt eine LIFO-Auflistung (Last In, First Out) von Objekten dar.Represents a last in, first out (LIFO) collection of objects.

Weitere Informationen finden Sie unter Häufig verwendete Auflistungstypen, Auswählen einer Auflistungsklasse und System.Collections.Generic.For additional information, see Commonly Used Collection Types, Selecting a Collection Class, and System.Collections.Generic.

System.Collections.Concurrent-KlassenSystem.Collections.Concurrent Classes

In .NET Framework 4 oder höher stellen die Auflistungen im Namespace System.Collections.Concurrent effiziente threadsichere Vorgänge für den Zugriff auf Auflistungselemente aus mehreren Threads bereit.In the .NET Framework 4 or newer, the collections in the System.Collections.Concurrent namespace provide efficient thread-safe operations for accessing collection items from multiple threads.

Die Klassen im System.Collections.Concurrent-Namespace sollten anstelle von entsprechenden Typen in System.Collections.Generic- und System.Collections-Namespaces verwendet werden, wenn mehrere Threads gleichzeitig auf die Auflistung zugreifen.The classes in the System.Collections.Concurrent namespace should be used instead of the corresponding types in the System.Collections.Generic and System.Collections namespaces whenever multiple threads are accessing the collection concurrently. Weitere Informationen finden Sie unter Threadsichere Auflistungen und System.Collections.Concurrent.For more information, see Thread-Safe Collections and System.Collections.Concurrent.

Einige der in die System.Collections.Concurrent-Namespaces aufgenommenen Klassen sind BlockingCollection<T>, ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T> und ConcurrentStack<T>.Some classes included in the System.Collections.Concurrent namespace are BlockingCollection<T>, ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T>, and ConcurrentStack<T>.

System.Collections-KlassenSystem.Collections Classes

Bei den Klassen im System.Collections-Namespace werden Elemente nicht als speziell typisierte Objekte, sondern als Objekte vom Typ Object gespeichert.The classes in the System.Collections namespace do not store elements as specifically typed objects, but as objects of type Object.

Sofern möglich sollten die generischen Auflistungen im System.Collections.Generic-Namespace oder System.Collections.Concurrent-Namespace anstelle der älteren Typen im System.Collections-Namespace verwendet werden.Whenever possible, you should use the generic collections in the System.Collections.Generic namespace or the System.Collections.Concurrent namespace instead of the legacy types in the System.Collections namespace.

In der folgenden Tabelle werden einige der häufig verwendeten Klassen im System.Collections-Namespace aufgelistet:The following table lists some of the frequently used classes in the System.Collections namespace:

KlasseClass BeschreibungDescription
ArrayList Stellt ein Array von Objekten dar, das je nach Bedarf dynamisch vergrößert wird.Represents an array of objects whose size is dynamically increased as required.
Hashtable Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die auf Grundlage des Hashcodes des Schlüssels geordnet sind.Represents a collection of key/value pairs that are organized based on the hash code of the key.
Queue Stellt eine FIFO-Auflistung (First In, First Out) von Objekten dar.Represents a first in, first out (FIFO) collection of objects.
Stack Stellt eine LIFO-Auflistung (Last In, First Out) von Objekten dar.Represents a last in, first out (LIFO) collection of objects.

Der System.Collections.Specialized-Namespace bietet spezialisierte und stark typisierte Auflistungsklassen, beispielsweise für Zeichenfolgenauflistungen sowie für Wörterbücher mit verketteten Listen und Hybridwörterbücher.The System.Collections.Specialized namespace provides specialized and strongly typed collection classes, such as string-only collections and linked-list and hybrid dictionaries.

Implementieren einer Auflistung von Schlüssel/Wert-PaarenImplementing a Collection of Key/Value Pairs

Die generische Auflistung Dictionary<TKey,TValue> ermöglicht es Ihnen, unter Verwendung des Schlüssels der einzelnen Elemente auf die Elemente einer Auflistung zuzugreifen.The Dictionary<TKey,TValue> generic collection enables you to access to elements in a collection by using the key of each element. Jede Hinzufügung zum Wörterbuch besteht aus einem Wert und dem zugeordneten Schlüssel.Each addition to the dictionary consists of a value and its associated key. Ein Wert kann anhand des zugehörigen Schlüssels schnell abgerufen werden, da die Dictionary-Klasse in Form einer Hashtabelle implementiert ist.Retrieving a value by using its key is fast because the Dictionary class is implemented as a hash table.

Das folgende Beispiel erstellt eine Dictionary-Auflistung und durchläuft das Wörterbuch unter Verwendung einer foreach-Anweisung.The following example creates a Dictionary collection and iterates through the dictionary by using a foreach statement.

private static void IterateThruDictionary()  
{  
    Dictionary<string, Element> elements = BuildDictionary();  

    foreach (KeyValuePair<string, Element> kvp in elements)  
    {  
        Element theElement = kvp.Value;  

        Console.WriteLine("key: " + kvp.Key);  
        Console.WriteLine("values: " + theElement.Symbol + " " +  
            theElement.Name + " " + theElement.AtomicNumber);  
    }  
}  

private static Dictionary<string, Element> BuildDictionary()  
{  
    var elements = new Dictionary<string, Element>();  

    AddToDictionary(elements, "K", "Potassium", 19);  
    AddToDictionary(elements, "Ca", "Calcium", 20);  
    AddToDictionary(elements, "Sc", "Scandium", 21);  
    AddToDictionary(elements, "Ti", "Titanium", 22);  

    return elements;  
}  

private static void AddToDictionary(Dictionary<string, Element> elements,  
    string symbol, string name, int atomicNumber)  
{  
    Element theElement = new Element();  

    theElement.Symbol = symbol;  
    theElement.Name = name;  
    theElement.AtomicNumber = atomicNumber;  

    elements.Add(key: theElement.Symbol, value: theElement);  
}  

public class Element  
{  
    public string Symbol { get; set; }  
    public string Name { get; set; }  
    public int AtomicNumber { get; set; }  
}  

Wenn stattdessen ein Auflistungsinitialisierer zum Erstellen der Dictionary-Auflistung verwendet werden soll, können Sie die BuildDictionary- und AddToDictionary-Methoden durch die folgende Methode ersetzen.To instead use a collection initializer to build the Dictionary collection, you can replace the BuildDictionary and AddToDictionary methods with the following method.

private static Dictionary<string, Element> BuildDictionary2()  
{  
    return new Dictionary<string, Element>  
    {  
        {"K",  
            new Element() { Symbol="K", Name="Potassium", AtomicNumber=19}},  
        {"Ca",  
            new Element() { Symbol="Ca", Name="Calcium", AtomicNumber=20}},  
        {"Sc",  
            new Element() { Symbol="Sc", Name="Scandium", AtomicNumber=21}},  
        {"Ti",  
            new Element() { Symbol="Ti", Name="Titanium", AtomicNumber=22}}  
    };  
}  

Im folgenden Beispiel werden die ContainsKey-Methode und die Item[TKey]-Eigenschaft von Dictionary verwendet, um anhand des Schlüssels schnell nach einem Element zu suchen.The following example uses the ContainsKey method and the Item[TKey] property of Dictionary to quickly find an item by key. Die Item-Eigenschaft ermöglicht den Zugriff auf ein Element in der elements-Auflistung unter Verwendung des elements[symbol]-Codes in C#.The Item property enables you to access an item in the elements collection by using the elements[symbol] in C#.

private static void FindInDictionary(string symbol)  
{  
    Dictionary<string, Element> elements = BuildDictionary();  

    if (elements.ContainsKey(symbol) == false)  
    {  
        Console.WriteLine(symbol + " not found");  
    }  
    else  
    {  
        Element theElement = elements[symbol];  
        Console.WriteLine("found: " + theElement.Name);  
    }  
}  

Im folgenden Beispiel wird stattdessen die TryGetValue-Methode verwendet, um anhand des Schlüssels schnell nach einem Element zu suchen.The following example instead uses the TryGetValue method quickly find an item by key.

private static void FindInDictionary2(string symbol)  
{  
    Dictionary<string, Element> elements = BuildDictionary();  

    Element theElement = null;  
    if (elements.TryGetValue(symbol, out theElement) == false)  
        Console.WriteLine(symbol + " not found");  
    else  
        Console.WriteLine("found: " + theElement.Name);  
}  

Verwenden von LINQ zum Zugriff auf eine AuflistungUsing LINQ to Access a Collection

LINQ (Language-Integrated Query) kann verwendet werden, um auf Auflistungen zuzugreifen.LINQ (Language-Integrated Query) can be used to access collections. LINQ-Abfragen stellen Filter-, Sortier- und Gruppierungsfunktionen bereit.LINQ queries provide filtering, ordering, and grouping capabilities. Weitere Informationen finden Sie unter Erste Schritte mit LINQ in C#.For more information, see Getting Started with LINQ in C#.

Im folgenden Beispiel wird eine LINQ-Abfrage für eine generische List ausgeführt.The following example runs a LINQ query against a generic List. Die LINQ-Abfrage gibt eine andere Auflistung zurück, die die Ergebnisse enthält.The LINQ query returns a different collection that contains the results.

private static void ShowLINQ()  
{  
    List<Element> elements = BuildList();  

    // LINQ Query.  
    var subset = from theElement in elements  
                 where theElement.AtomicNumber < 22  
                 orderby theElement.Name  
                 select theElement;  

    foreach (Element theElement in subset)  
    {  
        Console.WriteLine(theElement.Name + " " + theElement.AtomicNumber);  
    }  

    // Output:  
    //  Calcium 20  
    //  Potassium 19  
    //  Scandium 21  
}  

private static List<Element> BuildList()  
{  
    return new List<Element>  
    {  
        { new Element() { Symbol="K", Name="Potassium", AtomicNumber=19}},  
        { new Element() { Symbol="Ca", Name="Calcium", AtomicNumber=20}},  
        { new Element() { Symbol="Sc", Name="Scandium", AtomicNumber=21}},  
        { new Element() { Symbol="Ti", Name="Titanium", AtomicNumber=22}}  
    };  
}  

public class Element  
{  
    public string Symbol { get; set; }  
    public string Name { get; set; }  
    public int AtomicNumber { get; set; }  
}  

Sortieren einer AuflistungSorting a Collection

Das folgende Beispiel zeigt ein Verfahren zum Sortieren einer Auflistung.The following example illustrates a procedure for sorting a collection. In dem Beispiel werden Instanzen der Car-Klasse sortiert, die in List<T> gespeichert sind.The example sorts instances of the Car class that are stored in a List<T>. Die Car-Klasse implementiert die IComparable<T>-Schnittstelle, die die Implementierung der CompareTo-Methode erfordert.The Car class implements the IComparable<T> interface, which requires that the CompareTo method be implemented.

Jeder Aufruf der CompareTo-Methode führt einen einzelnen Vergleich aus, der für die Sortierung verwendet wird.Each call to the CompareTo method makes a single comparison that is used for sorting. Vom Benutzer erstellter Code in der CompareTo-Methode gibt einen Wert für jeden Vergleich des aktuellen Objekts mit einem anderen Objekt zurück.User-written code in the CompareTo method returns a value for each comparison of the current object with another object. Der zurückgegebene Wert ist kleiner als Null, wenn das aktuelle Objekt kleiner ist als das andere Objekt, größer als Null, wenn das aktuelle Objekt größer als das andere Objekt ist und Null, wenn beide Objekt gleich groß sind.The value returned is less than zero if the current object is less than the other object, greater than zero if the current object is greater than the other object, and zero if they are equal. Dies ermöglicht es Ihnen, in dem Code die Kriterien für größer als, kleiner als und gleich zu definieren.This enables you to define in code the criteria for greater than, less than, and equal.

In der ListCars-Methode sortiert die cars.Sort()-Anweisung die Liste.In the ListCars method, the cars.Sort() statement sorts the list. Dieser Aufruf der Sort-Methode von List<T> führt dazu, dass die CompareTo-Methode für die Car-Objekte in der List automatisch aufgerufen wird.This call to the Sort method of the List<T> causes the CompareTo method to be called automatically for the Car objects in the List.

private static void ListCars()  
{  
    var cars = new List<Car>  
    {  
        { new Car() { Name = "car1", Color = "blue", Speed = 20}},  
        { new Car() { Name = "car2", Color = "red", Speed = 50}},  
        { new Car() { Name = "car3", Color = "green", Speed = 10}},  
        { new Car() { Name = "car4", Color = "blue", Speed = 50}},  
        { new Car() { Name = "car5", Color = "blue", Speed = 30}},  
        { new Car() { Name = "car6", Color = "red", Speed = 60}},  
        { new Car() { Name = "car7", Color = "green", Speed = 50}}  
    };  

    // Sort the cars by color alphabetically, and then by speed  
    // in descending order.  
    cars.Sort();  

    // View all of the cars.  
    foreach (Car thisCar in cars)  
    {  
        Console.Write(thisCar.Color.PadRight(5) + " ");  
        Console.Write(thisCar.Speed.ToString() + " ");  
        Console.Write(thisCar.Name);  
        Console.WriteLine();  
    }  

    // Output:  
    //  blue  50 car4  
    //  blue  30 car5  
    //  blue  20 car1  
    //  green 50 car7  
    //  green 10 car3  
    //  red   60 car6  
    //  red   50 car2  
}  

public class Car : IComparable<Car>  
{  
    public string Name { get; set; }  
    public int Speed { get; set; }  
    public string Color { get; set; }  

    public int CompareTo(Car other)  
    {  
        // A call to this method makes a single comparison that is  
        // used for sorting.  

        // Determine the relative order of the objects being compared.  
        // Sort by color alphabetically, and then by speed in  
        // descending order.  

        // Compare the colors.  
        int compare;  
        compare = String.Compare(this.Color, other.Color, true);  

        // If the colors are the same, compare the speeds.  
        if (compare == 0)  
        {  
            compare = this.Speed.CompareTo(other.Speed);  

            // Use descending order for speed.  
            compare = -compare;  
        }  

        return compare;  
    }  
}  

Definieren einer benutzerdefinierten AuflistungDefining a Custom Collection

Sie können eine Auflistung definieren, indem Sie die IEnumerable<T>- oder IEnumerable-Schnittstelle implementieren.You can define a collection by implementing the IEnumerable<T> or IEnumerable interface. Weitere Informationen finden Sie unter Vorgehensweise: Zugreifen auf Auflistungsklassen mit Foreach.For additional information, see How to: Access a Collection Class with foreach.

Sie können zwar eine benutzerdefinierte Auflistung definieren, in der Regel ist es aber besser, die in .NET Framework enthaltenen Auflistungen zu verwenden. Diese werden unter Arten von Auflistungen weiter oben in diesem Thema beschrieben.Although you can define a custom collection, it is usually better to instead use the collections that are included in the .NET Framework, which are described in Kinds of Collections earlier in this topic.

Im folgenden Beispiel wird die benutzerdefinierte Auflistungsklasse AllColors definiert.The following example defines a custom collection class named AllColors. Diese Klasse implementiert die IEnumerable-Schnittstelle, die die Implementierung der GetEnumerator-Methode erfordert.This class implements the IEnumerable interface, which requires that the GetEnumerator method be implemented.

Die GetEnumerator-Methode gibt eine Instanz der ColorEnumerator-Klasse zurück.The GetEnumerator method returns an instance of the ColorEnumerator class. ColorEnumerator implementiert die IEnumerator-Schnittstelle, die die Implementierung der Current-Eigenschaft, der MoveNext-Methode und der Reset-Methode erfordert.ColorEnumerator implements the IEnumerator interface, which requires that the Current property, MoveNext method, and Reset method be implemented.

private static void ListColors()  
{  
    var colors = new AllColors();  

    foreach (Color theColor in colors)  
    {  
        Console.Write(theColor.Name + " ");  
    }  
    Console.WriteLine();  
    // Output: red blue green  
}  

// Collection class.  
public class AllColors : System.Collections.IEnumerable  
{  
    Color[] _colors =  
    {  
        new Color() { Name = "red" },  
        new Color() { Name = "blue" },  
        new Color() { Name = "green" }  
    };  

    public System.Collections.IEnumerator GetEnumerator()  
    {  
        return new ColorEnumerator(_colors);  

        // Instead of creating a custom enumerator, you could  
        // use the GetEnumerator of the array.  
        //return _colors.GetEnumerator();  
    }  

    // Custom enumerator.  
    private class ColorEnumerator : System.Collections.IEnumerator  
    {  
        private Color[] _colors;  
        private int _position = -1;  

        public ColorEnumerator(Color[] colors)  
        {  
            _colors = colors;  
        }  

        object System.Collections.IEnumerator.Current  
        {  
            get  
            {  
                return _colors[_position];  
            }  
        }  

        bool System.Collections.IEnumerator.MoveNext()  
        {  
            _position++;  
            return (_position < _colors.Length);  
        }  

        void System.Collections.IEnumerator.Reset()  
        {  
            _position = -1;  
        }  
    }  
}  

// Element class.  
public class Color  
{  
    public string Name { get; set; }  
}  

IteratorenIterators

Ein Iterator wird verwendet, um eine benutzerdefinierte Iteration durch eine Auflistung auszuführen.An iterator is used to perform a custom iteration over a collection. Ein Iterator kann eine Methode oder ein get-Accessor sein.An iterator can be a method or a get accessor. Ein Iterator verwendet eine yield return-Anweisung, um jedes Element der Auflistung separat zurückzugeben.An iterator uses a yield return statement to return each element of the collection one at a time.

Sie rufen einen Iterator mithilfe einer foreach-Anweisung auf.You call an iterator by using a foreach statement. Jede Iteration der foreach-Schleife ruft den Iterator auf.Each iteration of the foreach loop calls the iterator. Wenn eine yield return-Anweisung im Iterator erreicht ist, wird ein Ausdruck zurückgegeben, und die aktuelle Position im Code wird beibehalten.When a yield return statement is reached in the iterator, an expression is returned, and the current location in code is retained. Wenn der Iterator das nächste Mal aufgerufen wird, wird die Ausführung von dieser Position neu gestartet.Execution is restarted from that location the next time that the iterator is called.

Weitere Informationen finden Sie unter Iteratoren (C#).For more information, see Iterators (C#).

Im folgenden Beispiel wird eine Iteratormethode verwendet.The following example uses an iterator method. Die Iteratormethode verfügt über eine yield return-Anweisung, die sich innerhalb einer for-Schleife befindet.The iterator method has a yield return statement that is inside a for loop. In der ListEvenNumbers-Methode erstellt jede Iteration des foreach-Anweisungstexts einen Aufruf der Iteratormethode, der zur nächsten yield return-Anweisung übergeht.In the ListEvenNumbers method, each iteration of the foreach statement body creates a call to the iterator method, which proceeds to the next yield return statement.

private static void ListEvenNumbers()  
{  
    foreach (int number in EvenSequence(5, 18))  
    {  
        Console.Write(number.ToString() + " ");  
    }  
    Console.WriteLine();  
    // Output: 6 8 10 12 14 16 18  
}  

private static IEnumerable<int> EvenSequence(  
    int firstNumber, int lastNumber)  
{  
    // Yield even numbers in the range.  
    for (var number = firstNumber; number <= lastNumber; number++)  
    {  
        if (number % 2 == 0)  
        {  
            yield return number;  
        }  
    }  
}  

Siehe auchSee Also

Objekt- und AuflistungsinitialisiererObject and Collection Initializers
Programmierkonzepte (C#)Programming Concepts (C#)
Option Strict-AnweisungOption Strict Statement
LINQ to Objects (C#)LINQ to Objects (C#)
Parallel LINQ (PLINQ) (Paralleles LINQ (PLINQ))Parallel LINQ (PLINQ)
Auflistungen und DatenstrukturenCollections and Data Structures
Erstellen und Bearbeiten von SammlungenCreating and Manipulating Collections
Auswählen einer AuflistungsklasseSelecting a Collection Class
Vergleiche und Sortierungen innerhalb von AuflistungenComparisons and Sorts Within Collections
Verwenden von generischen AuflistungenWhen to Use Generic Collections
Gewusst wie: Zugreifen auf Sammlungsklassen mit foreachHow to: Access a Collection Class with foreach