Freigeben über

Auflistungen (C# und Visual Basic)

  • Artikel

Für viele Anwendungen möchten Sie Gruppen verknüpfte Objekte erstellen und verwalten.Zum Gruppieren von Objekten gibt es zwei Möglichkeiten: das Erstellen von Objektarrays und das Erstellen von Auflistungen von Objekten.

Arrays sind für das Erstellen und Arbeiten mit einer festen Anzahl von stark typisierten Objekten besonders hilfreich.Weitere Informationen zu Arrays, finden Sie unter Arrays in Visual Basic oder Arrays (C#-Programmierhandbuch).

Auflistungen stellen eine flexiblere Möglichkeit, mit Gruppen - Objekten zu arbeiten.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.Für einige Auflistungen können Sie einen Schlüssel an jedes Objekt zuweisen, das in die Auflistung einfügen, sodass Sie das Objekt schnell abrufen können, indem Sie Schlüssel verwenden.

Eine Auflistung ist eine Klasse. Daher müssen Sie eine neue Auflistung deklarieren, bevor Sie dieser Auflistung Elemente hinzufügen können.

Wenn die Auflistung Elemente eines Datentyps enthält, können Sie eine der Klassen im - Namespace System.Collections.Generic verwenden.Eine generische Auflistung erzwingt Typsicherheit, sodass der Auflistung kein anderer Datentyp hinzugefügt werden kann.Wenn Sie ein Element aus einer generischen Auflistung abrufen, brauchen Sie dessen Datentyp nicht zu bestimmen oder zu konvertieren.

HinweisHinweis

Für die Beispiele in diesem Thema schließen Sie Imports-Anweisungen (Visual Basic) oder using-Direktiven (C#) für die System.Collections.Generic- und System.Linq-Namespaces ein.

In diesem Thema

  • Verwenden einer einfachen Auflistung

  • Arten von Auflistungen

    • System.Collections.Generic-Klassen

    • System.Collections.Concurrent-Klassen

    • System.Collections-Klassen

    • Visual Basic-Auflistungsklasse

  • Implementieren einer Auflistung von Schlüssel-Wert-Paaren

  • Verwenden LINQs, das auf einer Auflistung zuzugreifen

  • Sortieren einer Auflistung

  • Definieren einer benutzerdefinierten Auflistung

  • Iteratoren

Verwenden einer einfachen Auflistung

Die Beispiele in diesem Abschnitt verwenden die generische Klasse List<T>, die Ihnen ermöglicht, mit einer stark typisierten Liste von - Objekten zu arbeiten.

Im folgenden Beispiel wird eine Liste von Zeichenfolgen und durchläuft dann durch die Zeichenfolgen durch, indem eine Anweisung Für jedes... Next-Schleife (Visual Basic) oder foreach (C#) verwendet.

' Create a list of strings.
Dim salmons As New List(Of String)
salmons.Add("chinook")
salmons.Add("coho")
salmons.Add("pink")
salmons.Add("sockeye")

' Iterate through the list.
For Each salmon As String In salmons
    Console.Write(salmon & " ")
Next
'Output: chinook coho pink sockeye

// 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.Weitere Informationen finden Sie unter Auflistungsinitialisierer (Visual Basic) oder unter Objekt- und Auflistungsinitialisierer (C#-Programmierhandbuch).

Das folgende Beispiel entspricht dem vorhergehenden Beispiel, außer einem Auflistungsinitialisierer verwendet wird, um Elemente hinzu.

' Create a list of strings by using a
' collection initializer.
Dim salmons As New List(Of String) From
    {"chinook", "coho", "pink", "sockeye"}

For Each salmon As String In salmons
    Console.Write(salmon & " ")
Next
'Output: chinook coho pink sockeye

// 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 eine - Anweisung Für... Next-Schleife (Visual Basic) oder für (C#) anstelle einer For Each-Anweisung verwenden, um eine Auflistung zu durchlaufen.Sie erreichen dies, indem Sie auf die Auflistungselemente durch die Indexposition zugreifen.Der Index der Elementbeginnung mit 0 und der endet an der Elementanzahl minus 1.

Im folgenden Beispiel wird durch die Elemente einer Auflistung durch, indem For…Next anstelle For Each verwendet.

Dim salmons As New List(Of String) From
    {"chinook", "coho", "pink", "sockeye"}

For index = 0 To salmons.Count - 1
    Console.Write(salmons(index) & " ")
Next
'Output: chinook coho pink sockeye

// 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 entfernt ein Element aus der Auflistung, indem das - Objekt angibt, um zu entfernen.

' Create a list of strings by using a
' collection initializer.
Dim salmons As New List(Of String) From
    {"chinook", "coho", "pink", "sockeye"}

' Remove an element in the list by specifying
' the object.
salmons.Remove("coho")

For Each salmon As String In salmons
    Console.Write(salmon & " ")
Next
'Output: chinook pink sockeye

// 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 entfernt Elemente aus einer generischen Liste.Anstelle einer For Each-Anweisung ist eine Anweisung Für... Next-Schleife (Visual Basic) oder für (C#), die in absteigender Reihenfolge durchläuft, verwendet.Dies liegt daran, dass die RemoveAt-Methode Elemente nach einem entfernten Element bewirkt, dass einen niedrigeren Indexwert verfügen.

Dim numbers As New List(Of Integer) From
    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

' Remove odd numbers.
For index As Integer = numbers.Count - 1 To 0 Step -1
    If numbers(index) Mod 2 = 1 Then
        ' Remove the element by specifying
        ' the zero-based index in the list.
        numbers.RemoveAt(index)
    End If
Next

' Iterate through the list.
' A lambda expression is placed in the ForEach method
' of the List(T) object.
numbers.ForEach(
    Sub(number) Console.Write(number & " "))
' Output: 0 2 4 6 8

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 eine eigene Klasse definieren.Im folgenden Beispiel wird die Galaxy-Klasse, die von List<T> verwendet wird, im Code definiert.

Private Sub IterateThroughList()
    Dim theGalaxies As New List(Of Galaxy) From
        {
            New Galaxy With {.Name = "Tadpole", .MegaLightYears = 400},
            New Galaxy With {.Name = "Pinwheel", .MegaLightYears = 25},
            New Galaxy With {.Name = "Milky Way", .MegaLightYears = 0},
            New Galaxy With {.Name = "Andromeda", .MegaLightYears = 3}
        }

    For Each theGalaxy In theGalaxies
        With theGalaxy
            Console.WriteLine(.Name & "  " & .MegaLightYears)
        End With
    Next

    ' Output:
    '  Tadpole  400
    '  Pinwheel  25
    '  Milky Way  0
    '  Andromeda  3
End Sub

Public Class Galaxy
    Public Property Name As String
    Public Property MegaLightYears As Integer
End Class

private 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 Auflistungen

Viele allgemeine Auflistungen werden von .NET Framework bereitgestellt.Jeder Typ Auflistung ist für einen bestimmten Zweck entworfen.

Die folgenden Gruppen von Auflistungsklassen werden in diesem Abschnitt beschrieben:

  • System.Collections.Generic-Klassen

  • System.Collections.Concurrent-Klassen

  • System.Collections-Klassen

  • Klasse Visual Basics Collection

ybcx56wz.collapse_all(de-de,VS.110).gifSystem.Collections.Generic-Klassen

Sie können eine generische Auflistung erstellen, indem Sie eine der Klassen im - Namespace System.Collections.Generic verwenden.Eine generische Auflistung ist sinnvoll, wenn jedes Element der Auflistung zum gleichen Datentyp gehört.Eine generische Auflistung erzwingt starke Typisierung, indem nur den gewünschten hinzugefügt werden kann, Datentyp.

In der folgenden Tabelle werden einige der häufig verwendeten Klassen des - Namespace System.Collections.Generic auf:

Klasse

Beschreibung

[ T:System.Collections.Generic.Dictionary`2 ]

Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, deren Reihenfolge anhand des Schlüssels bestimmt wird.

[ T:System.Collections.Generic.List`1 ]

Stellt eine Liste von - Objekten dar, auf die von Index zugegriffen werden kann.Stellt Methoden zur Suche, Sortierung bereit und ändert Listen.

[ T:System.Collections.Generic.Queue`1 ]

Stellt ein erstes in, zuerst out Auflistung (First-In-First-Out) - Objekte dar.

[ T:System.Collections.Generic.SortedList`2 ]

Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die auf Grundlage der zugeordneten IComparer<T>-Implementierung nach den Schlüsseln sortiert sind.

[ T:System.Collections.Generic.Stack`1 ]

Stellt ein Letztes in, zuerst out Auflistung (Last-In-First-Out) - Objekte dar.

Zusätzliche Informationen finden Sie unter Häufig verwendete Auflistungstypen, Auswählen einer Auflistungsklasse und System.Collections.Generic.

ybcx56wz.collapse_all(de-de,VS.110).gifSystem.Collections.Concurrent-Klassen

In .NET Framework 4 stellen die Auflistungen im System.Collections.Concurrent-Namespace effiziente threadsichere Operationen für den Zugriff auf Auflistungselemente aus mehreren Threads bereit.

Die Klassen im - Namespace System.Collections.Concurrent sollten anstelle von entsprechen Typen verwendet werden System.Collections.Generic und die System.Collections-Namespaces, wenn mehrere Threads gleichzeitig auf die Auflistung zugreifen.Weitere Informationen finden Sie unter Threadsichere Auflistungen und System.Collections.Concurrent.

Einige Klassen, die im System.Collections.Concurrent-Namespace enthalten sind, BlockingCollection<T>, ConcurrentDictionary<TKey, TValue>, ConcurrentQueue<T> und ConcurrentStack<T>.

ybcx56wz.collapse_all(de-de,VS.110).gifSystem.Collections-Klassen

Bei den Klassen im System.Collections-Namespace werden Elemente nicht als speziell typisierte Objekte, sondern als Objekte vom Typ Object gespeichert.

Sofern möglich, sollten die generischen Auflistungen im - Namespace System.Collections.Generic oder im System.Collections.Concurrent-Namespace anstelle der älteren verwenden sollten, System.Collections-Typen im - Namespace ein.

In der folgenden Tabelle werden einige der häufig verwendeten Klassen im - Namespace System.Collections auf:

Klasse

Beschreibung

[ T:System.Collections.ArrayList ]

Stellt ein Array von - Objekten dar, dessen Größe je nach Bedarf dynamisch erhöht wird.

[ T:System.Collections.Hashtable ]

Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die auf Grundlage des Hashcodes des Schlüssels geordnet sind.

[ T:System.Collections.Queue ]

Stellt ein erstes in, zuerst out Auflistung (First-In-First-Out) - Objekte dar.

[ T:System.Collections.Stack ]

Stellt ein Letztes in, zuerst out Auflistung (Last-In-First-Out) - Objekte dar.

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.

ybcx56wz.collapse_all(de-de,VS.110).gifVisual Basic-Auflistungsklasse

Sie können die - Klasse Visual Basics Collection verwenden, um auf ein Auflistungselement zuzugreifen, indem Sie entweder einen numerischen Index oder eine String Schlüssel verwenden.Sie können Elemente einem Auflistungsobjekt entweder mit oder ohne Angabe eines Schlüssels hinzufügen.Wenn Sie ein Element ohne einen Schlüssel hinzufügen, müssen Sie seinen numerischen Index verwenden, um darauf zuzugreifen.

Die - Klasse Visual Basics Collection speichert alle Elemente als - Typ Object, sodass Sie ein Element mit einem beliebigen Datentyp hinzufügen.Es gibt keine Vorkehrung, die das Hinzufügen ungeeigneter Datentypen verhindert.

Wenn Sie die Klasse Visual Basics Collection verwenden, hat das erste Element in einer Auflistung einen Index von 1.Dies unterscheidet sich von den .NET Framework-Auflistungsklassen, für die der Startindex 0 ist.

Sofern möglich, sollten die generischen Auflistungen im - Namespace System.Collections.Generic oder im System.Collections.Concurrent-Namespace anstelle der - Klasse Visual Basics Collection verwenden sollten.

Weitere Informationen finden Sie unter Collection.

Implementieren einer Auflistung von Schlüssel-Wert-Paaren

Die Dictionary<TKey, TValue> generische Auflistung ermöglicht es Ihnen, auf die Elemente einer Auflistung zugreifen, indem sie die Schlüssel jedes Elements verwendet.Jede Hinzufügung zum Wörterbuch besteht aus einem Wert und dem zugeordneten Schlüssel.Wenn ein Wert, indem es die Schlüssel abzurufen, ist schnell verwendet, da die Dictionary-Klasse als Hashtabelle implementiert wird.

Im folgenden Beispiel wird eine Dictionary-Auflistung und durchläuft das Wörterbuch über, indem eine For Each-Anweisung verwendet.

Private Sub IterateThroughDictionary()
    Dim elements As Dictionary(Of String, Element) = BuildDictionary()

    For Each kvp As KeyValuePair(Of String, Element) In elements
        Dim theElement As Element = kvp.Value

        Console.WriteLine("key: " & kvp.Key)
        With theElement
            Console.WriteLine("values: " & .Symbol & " " &
                .Name & " " & .AtomicNumber)
        End With
    Next
End Sub

Private Function BuildDictionary() As Dictionary(Of String, Element)
    Dim elements As New Dictionary(Of String, Element)

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

    Return elements
End Function

Private Sub AddToDictionary(ByVal elements As Dictionary(Of String, Element),
ByVal symbol As String, ByVal name As String, ByVal atomicNumber As Integer)
    Dim theElement As New Element

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

    elements.Add(Key:=theElement.Symbol, value:=theElement)
End Sub

Public Class Element
    Public Property Symbol As String
    Public Property Name As String
    Public Property AtomicNumber As Integer
End Class

private 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 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 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; }
}

Um einen Auflistungsinitialisierer stattdessen mit die Dictionary-Auflistung erstellen, können Sie die BuildDictionary und AddToDictionary-Methoden durch die folgende - Methode ersetzen.

Private Function BuildDictionary2() As Dictionary(Of String, Element)
    Return New Dictionary(Of String, Element) From
        {
            {"K", New Element With
                {.Symbol = "K", .Name = "Potassium", .AtomicNumber = 19}},
            {"Ca", New Element With
                {.Symbol = "Ca", .Name = "Calcium", .AtomicNumber = 20}},
            {"Sc", New Element With
                {.Symbol = "Sc", .Name = "Scandium", .AtomicNumber = 21}},
            {"Ti", New Element With
                {.Symbol = "Ti", .Name = "Titanium", .AtomicNumber = 22}}
        }
End Function

private 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 wird die ContainsKey-Methode und die - Eigenschaft Item von Dictionary, um ein Element nach Schlüssel schnell zu suchen.Die Item-Eigenschaft ermöglicht es, auf ein Element in der elements-Auflistung, indem der elements(symbol) Code in Visual Basic zuzugreifen verwendet, oder elements[symbol] in C#.

Private Sub FindInDictionary(ByVal symbol As String)
    Dim elements As Dictionary(Of String, Element) = BuildDictionary()

    If elements.ContainsKey(symbol) = False Then
        Console.WriteLine(symbol & " not found")
    Else
        Dim theElement = elements(symbol)
        Console.WriteLine("found: " & theElement.Name)
    End If
End Sub

private 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 suchen schnell ein Element nach Schlüssel.

Private Sub FindInDictionary2(ByVal symbol As String)
    Dim elements As Dictionary(Of String, Element) = BuildDictionary()

    Dim theElement As Element = Nothing
    If elements.TryGetValue(symbol, theElement) = False Then
        Console.WriteLine(symbol & " not found")
    Else
        Console.WriteLine("found: " & theElement.Name)
    End If
End Sub

private 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 LINQs, das auf einer Auflistung zuzugreifen

LINQ (Language-Integrated Query) kann verwendet werden, um auf Auflistungen zuzugreifen.LINQ-Abfragen stellen Filter-, Sortier- und Gruppierungsfunktionen.Weitere Informationen finden Sie unter Erste Schritte mit LINQ in Visual Basic oder unter Erste Schritte mit LINQ in C#.

Im folgenden Beispiel wird eine LINQ-Abfrage für generisches List aus.Die LINQ-Abfrage gibt eine andere Auflistung zurück, die die Ergebnisse enthält.

Private Sub ShowLINQ()
    Dim elements As List(Of Element) = BuildList()

    ' LINQ Query.
    Dim subset = From theElement In elements
                  Where theElement.AtomicNumber < 22
                  Order By theElement.Name

    For Each theElement In subset
        Console.WriteLine(theElement.Name & " " & theElement.AtomicNumber)
    Next

    ' Output:
    '  Calcium 20
    '  Potassium 19
    '  Scandium 21
End Sub

Private Function BuildList() As List(Of Element)
    Return New List(Of Element) From
        {
            {New Element With
                {.Symbol = "K", .Name = "Potassium", .AtomicNumber = 19}},
            {New Element With
                {.Symbol = "Ca", .Name = "Calcium", .AtomicNumber = 20}},
            {New Element With
                {.Symbol = "Sc", .Name = "Scandium", .AtomicNumber = 21}},
            {New Element With
                {.Symbol = "Ti", .Name = "Titanium", .AtomicNumber = 22}}
        }
End Function

Public Class Element
    Public Property Symbol As String
    Public Property Name As String
    Public Property AtomicNumber As Integer
End Class

private 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 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 Auflistung

Das folgende Beispiel veranschaulicht ein Verfahren zum Sortieren einer Auflistung.Die Beispielssortierungsinstanzen Car-Klasse, die in List<T> gespeichert werden.Die Car-Klasse implementiert die - Schnittstelle IComparable<T>, die erfordert, dass die CompareTo-Methode implementiert ist.

Jeder Aufruf der - Methode CompareTo vergleicht einzelnen, der zum Sortieren verwendet wird.Vom Benutzer erstellter Code in der CompareTo-Methode gibt einen Wert für jeden Vergleich des aktuellen Objekts mit einem anderen Objekt zurück.Der zurückgegebene Wert ist kleiner als null, wenn das aktuelle Objekt kleiner als das andere - Objekt ist, größer als null, wenn das aktuelle Objekt größer als das andere - Objekt ist, und wenn sie gleich sind.Dies ermöglicht es Ihnen, in dem Code definieren die Kriterien für größer als, weniger als und gleich.

In der ListCars-Methode die cars.Sort()-Anweisungssortierungen die Liste.Dieser Aufruf der - Methode SortList<T> wird die CompareTo-Methode, für die Car-Objekte in List automatisch aufgerufen werden.

Public Sub ListCars()

    ' Create some new cars.
    Dim cars As New List(Of Car) From
    {
        New Car With {.Name = "car1", .Color = "blue", .Speed = 20},
        New Car With {.Name = "car2", .Color = "red", .Speed = 50},
        New Car With {.Name = "car3", .Color = "green", .Speed = 10},
        New Car With {.Name = "car4", .Color = "blue", .Speed = 50},
        New Car With {.Name = "car5", .Color = "blue", .Speed = 30},
        New Car With {.Name = "car6", .Color = "red", .Speed = 60},
        New Car With {.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.
    For Each thisCar As Car In cars
        Console.Write(thisCar.Color.PadRight(5) & " ")
        Console.Write(thisCar.Speed.ToString & " ")
        Console.Write(thisCar.Name)
        Console.WriteLine()
    Next

    ' Output:
    '  blue  50 car4
    '  blue  30 car5
    '  blue  20 car1
    '  green 50 car7
    '  green 10 car3
    '  red   60 car6
    '  red   50 car2
End Sub

Public Class Car
    Implements IComparable(Of Car)

    Public Property Name As String
    Public Property Speed As Integer
    Public Property Color As String

    Public Function CompareTo(ByVal other As Car) As Integer _
        Implements System.IComparable(Of Car).CompareTo
        ' 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.
        Dim compare As Integer
        compare = String.Compare(Me.Color, other.Color, True)

        ' If the colors are the same, compare the speeds.
        If compare = 0 Then
            compare = Me.Speed.CompareTo(other.Speed)

            ' Use descending order for speed.
            compare = -compare
        End If

        Return compare
    End Function
End Class

private 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 Auflistung

Sie können eine Auflistung definieren, indem Sie die IEnumerable<T> oder IEnumerable-Schnittstelle implementieren.Weitere Informationen finden Sie unter Enumerieren einer Auflistung und Gewusst wie: Zugreifen auf Auflistungsklassen mit foreach (C#-Programmierhandbuch).

Obwohl Sie eine benutzerdefinierte Auflistung definieren können, ist es normalerweise besser, die Auflistungen stattdessen zu verwenden, die in .NET Framework enthalten sind, die in Kinds of Collections weiter oben in diesem Thema beschrieben werden.

Im folgenden Beispiel wird eine benutzerdefinierte Auflistungsklasse, die AllColors genannt wird.Diese Klasse implementiert die - Schnittstelle IEnumerable, die erfordert, dass die GetEnumerator-Methode implementiert ist.

Die GetEnumerator-Methode gibt eine Instanz der - Klasse ColorEnumerator zurück.ColorEnumeratorIEnumerator implementiert die - Schnittstelle, die erfordert, dass die Current-Eigenschaft, die MoveNext-Methode und die - Methode Reset implementiert werden.

Public Sub ListColors()
    Dim colors As New AllColors()

    For Each theColor As Color In colors
        Console.Write(theColor.Name & " ")
    Next
    Console.WriteLine()
    ' Output: red blue green
End Sub

' Collection class.
Public Class AllColors
    Implements System.Collections.IEnumerable

    Private _colors() As Color =
    {
        New Color With {.Name = "red"},
        New Color With {.Name = "blue"},
        New Color With {.Name = "green"}
    }

    Public Function GetEnumerator() As System.Collections.IEnumerator _
        Implements System.Collections.IEnumerable.GetEnumerator

        Return New ColorEnumerator(_colors)

        ' Instead of creating a custom enumerator, you could
        ' use the GetEnumerator of the array.
        'Return _colors.GetEnumerator
    End Function

    ' Custom enumerator.
    Private Class ColorEnumerator
        Implements System.Collections.IEnumerator

        Private _colors() As Color
        Private _position As Integer = -1

        Public Sub New(ByVal colors() As Color)
            _colors = colors
        End Sub

        Public ReadOnly Property Current() As Object _
            Implements System.Collections.IEnumerator.Current
            Get
                Return _colors(_position)
            End Get
        End Property

        Public Function MoveNext() As Boolean _
            Implements System.Collections.IEnumerator.MoveNext
            _position += 1
            Return (_position < _colors.Length)
        End Function

        Public Sub Reset() Implements System.Collections.IEnumerator.Reset
            _position = -1
        End Sub
    End Class
End Class

' Element class.
Public Class Color
    Public Property Name As String
End Class

private 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; }
}

Iteratoren

Ein Iterator wird verwendet, um eine benutzerdefinierte Iteration über einer Auflistung auszuführen.Ein Iterator kann eine Methode oder ein get Accessor sein.Ein Iterator verwendet eine - Anweisung Yield (Visual Basic) oder Rendite (C#), um jedes Element der Auflistung separat zurückzugeben.

Sie rufen den Iterator auf, indem Sie eine - Anweisung Für jedes... Next-Schleife (Visual Basic) oder foreach (C#) verwenden.Jede Iteration der Schleife For Each ruft den Iterator auf.Wenn eine Yield oder yield return-Anweisung im Iterator erreicht ist, wird ein Ausdruck zurückgegeben, und die aktuelle Position im Code wird beibehalten.Die Ausführung von diesem Speicherort beim nächsten Mal neu gestartet, dass der Iterator aufgerufen wird.

Weitere Informationen finden Sie unter Iteratoren (C# und Visual Basic).

Im folgenden Beispiel wird eine Iteratormethode.Die Iteratormethode verfügt über eine Yield oder yield return-Anweisung, die in einer Schleife Für... Next-Schleife (Visual Basic) oder für (C#) ist.In der ListEvenNumbers-Methode erstellt jede Iteration des For Each-Anweisungstexts einen Aufruf der Iteratormethode, die zu folgenden Yield oder zur yield return-Anweisung übergeht.

Public Sub ListEvenNumbers()
    For Each number As Integer In EvenSequence(5, 18)
        Console.Write(number & " ")
    Next
    Console.WriteLine()
    ' Output: 6 8 10 12 14 16 18
End Sub

Private Iterator Function EvenSequence(
ByVal firstNumber As Integer, ByVal lastNumber As Integer) _
As IEnumerable(Of Integer)

' Yield even numbers in the range.
    For number = firstNumber To lastNumber
        If number Mod 2 = 0 Then
            Yield number
        End If
    Next
End Function

private 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 auch

Aufgaben

Gewusst wie: Zugreifen auf Auflistungsklassen mit foreach (C#-Programmierhandbuch)

Referenz

Objekt- und Auflistungsinitialisierer (C#-Programmierhandbuch)

Option Strict-Anweisung

Konzepte

Auflistungsinitialisierer (Visual Basic)

LINQ-zu-Objekte

Paralleles LINQ (PLINQ)

Auswählen einer Auflistungsklasse

Vergleiche und Sortierungen innerhalb von Auflistungen

Verwenden von generischen Auflistungen

Weitere Ressourcen

Auflistungs-Methoden

Programmierungskonzepte

Auflistungen und Datenstrukturen

Erstellen und Verändern von Auflistungen