Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Für viele Anwendungen möchten Sie Gruppen verwandter Objekte erstellen und verwalten. Es gibt zwei Möglichkeiten zum Gruppieren von Objekten: durch Erstellen von Arrays von Objekten und durch Erstellen von Auflistungen von Objekten.
Arrays sind am nützlichsten für das Erstellen und Arbeiten mit einer festen Anzahl stark typierter Objekte. Informationen zu Arrays finden Sie unter Arrays.
Sammlungen bieten eine flexiblere Möglichkeit, mit Gruppen von Objekten zu arbeiten. Im Gegensatz zu Arrays kann die Gruppe der Objekte, mit der Sie arbeiten, dynamisch vergrößert und verkleinert werden, wenn sich die Anforderungen der Anwendung ändern. Bei einigen Auflistungen können Sie jedem Objekt, das Sie in die Auflistung einfügen, einen Schlüssel zuweisen, damit Sie das Objekt mithilfe des Schlüssels schnell abrufen können.
Eine Auflistung ist eine Klasse, daher müssen Sie eine Instanz der Klasse deklarieren, bevor Sie dieser Auflistung Elemente hinzufügen können.
Wenn Ihre Sammlung nur Elemente eines Datentyps enthält, können Sie eine der Klassen im System.Collections.Generic Namespace verwenden. Eine generische Sammlung erzwingt die Typsicherheit, sodass kein anderer Datentyp hinzugefügt werden kann. Wenn Sie ein Element aus einer generischen Auflistung abrufen, müssen Sie den Datentyp nicht ermitteln oder konvertieren.
Hinweis
Die Beispiele in diesem Thema enthalten Imports-Anweisungen für die Namespaces System.Collections.Generic
und System.Linq
.
Verwenden einer einfachen Auflistung
In den Beispielen in diesem Abschnitt wird die generische List<T> Klasse verwendet, mit der Sie mit einer stark typierten Liste von Objekten arbeiten können.
Das folgende Beispiel erstellt eine Liste von Zeichenfolgen und durchläuft dann die Zeichenfolgen mithilfe einer For Each... Next-Anweisung .
' 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
Wenn der Inhalt einer Auflistung im Voraus bekannt ist, können Sie einen Sammlungsinitialisierer verwenden, um die Auflistung zu initialisieren. Weitere Informationen finden Sie unter Sammlungsinitialisierer.
Das folgende Beispiel entspricht dem vorherigen Beispiel, mit Ausnahme eines Auflistungsinitialisierers, der zum Hinzufügen von Elementen zur Sammlung verwendet wird.
' 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
Sie können eine For…Next-Anweisung anstelle einer For Each
-Anweisung verwenden, um eine Sammlung zu durchlaufen. Dies erreichen Sie, indem Sie auf die Sammlungselemente über die Indexposition zugreifen. Der Index der Elemente beginnt bei 0 und endet mit der Elementanzahl minus 1.
Das folgende Beispiel durchläuft die Elemente einer Auflistung, indem es For…Next
anstelle von 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
Im folgenden Beispiel wird ein Element aus der Auflistung entfernt, indem das zu entfernende Objekt angegeben wird.
' 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
Im folgenden Beispiel werden Elemente aus einer generischen Liste entfernt. Anstelle einer For Each
-Anweisung wird eine For…Next-Anweisung verwendet, die die Elemente in absteigender Reihenfolge durchläuft. Dies liegt daran, dass die RemoveAt Methode Elemente nach einem entfernten Element zu einem niedrigeren Indexwert führt.
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
Für den Typ der Elemente in der List<T>, können Sie auch Ihre eigene Klasse definieren. Im folgenden Beispiel wird die Galaxy
Klasse, die von dem 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
Arten von Sammlungen
Viele allgemeine Auflistungen werden von .NET Framework bereitgestellt. Jeder Sammlungstyp ist für einen bestimmten Zweck konzipiert.
Einige der allgemeinen Sammlungsklassen werden in diesem Abschnitt beschrieben:
System.Collections.Generic Klassen
System.Collections.Concurrent Klassen
System.Collections Klassen
Visual Basic-Klasse
Collection
System.Collections.Generic-Klassen
Sie können eine generische Auflistung erstellen, indem Sie eine der Klassen im System.Collections.Generic Namespace verwenden. Eine generische Auflistung ist nützlich, wenn jedes Element in der Auflistung denselben Datentyp aufweist. Eine generische Auflistung erzwingt eine starke Typisierung, indem nur der gewünschte Datentyp hinzugefügt werden kann.
In der folgenden Tabelle sind einige der häufig verwendeten Klassen des System.Collections.Generic Namespaces aufgeführt:
Klasse | BESCHREIBUNG |
---|---|
Dictionary<TKey,TValue> | Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die basierend auf dem Schlüssel organisiert sind. |
List<T> | Stellt eine Liste von Objekten dar, auf die nach Index zugegriffen werden kann. Stellt Methoden zum Durchsuchen, Sortieren und Ändern von Listen bereit. |
Queue<T> | Stellt eine First In, First Out (FIFO)-Sammlung von Objekten dar. |
SortedList<TKey,TValue> | Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die basierend auf der zugeordneten IComparer<T> Implementierung nach Schlüssel sortiert werden. |
Stack<T> | Stellt eine LIFO-Auflistung (Last In, First Out) von Objekten dar. |
Weitere Informationen finden Sie unter Häufig verwendete Auflistungstypen, Auswählen einer Sammlungsklasse und System.Collections.Generic.
System.Collections.Concurrent-Klassen
In .NET Framework 4 oder höher bieten die Auflistungen im System.Collections.Concurrent Namespace effiziente threadsichere Vorgänge für den Zugriff auf Sammlungselemente aus mehreren Threads.
Die Klassen im System.Collections.Concurrent-Namespace sollten anstelle der entsprechenden Typen in den System.Collections.Generic- und System.Collections-Namespaces verwendet werden, wenn mehrere Threads gleichzeitig auf die Sammlung zugreifen. Weitere Informationen finden Sie unter Thread-Safe Sammlungen und System.Collections.Concurrent.
Einige Klassen, die im System.Collections.Concurrent Namespace enthalten sind, sind BlockingCollection<T>, ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T> und ConcurrentStack<T>.
System.Collections-Klassen
Die Klassen im System.Collections Namespace speichern keine Elemente als speziell typierte Objekte, sondern als Objekte vom Typ Object
.
Wann immer möglich, sollten Sie die generischen Auflistungen im System.Collections.Generic-Namespace oder im System.Collections.Concurrent-Namespace anstelle von Legacytypen im System.Collections
-Namespace verwenden.
In der folgenden Tabelle sind einige der häufig verwendeten Klassen im System.Collections
Namespace aufgeführt:
Klasse | BESCHREIBUNG |
---|---|
ArrayList | Stellt ein Array von Objekten dar, dessen Größe bei Bedarf dynamisch erhöht wird. |
Hashtable | Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die auf Grundlage des Hashcodes des Schlüssels geordnet sind. |
Queue | Stellt eine First In, First Out (FIFO)-Sammlung von Objekten dar. |
Stack | Stellt eine LIFO-Auflistung (Last In, First Out) von Objekten dar. |
Der System.Collections.Specialized Namespace stellt spezielle und stark typisierte Sammlungsklassen bereit, z. B. nur Zeichenfolgensammlungen und Verknüpfte Listen und Hybridwörterbücher.
Visual Basic-Auflistungsklasse
Sie können die Visual Basic-Klasse Collection verwenden, um auf ein Auflistungselement zuzugreifen, indem Sie entweder einen numerischen Index oder einen String
Schlüssel verwenden. Sie können einem Auflistungsobjekt Elemente entweder mit oder ohne Angabe eines Schlüssels hinzufügen. Wenn Sie ein Element ohne Schlüssel hinzufügen, müssen Sie dessen numerischen Index verwenden, um darauf zuzugreifen.
Die Visual Basic-Klasse Collection
speichert alle zugehörigen Elemente als Typ Object
, sodass Sie ein Element eines beliebigen Datentyps hinzufügen können. Es gibt keinen Schutz vor unangemessenen Datentypen, die hinzugefügt werden.
Wenn Sie die Visual Basic-Klasse Collection
verwenden, weist das erste Element in einer Auflistung einen Index von 1 auf. Dies unterscheidet sich von den .NET Framework-Auflistungsklassen, für die der Startindex 0 ist.
Wenn möglich, sollten Sie die generischen Auflistungen im System.Collections.Generic Namespace oder im System.Collections.Concurrent Namespace anstelle der Visual Basic-Klasse Collection
verwenden.
Weitere Informationen finden Sie unter Collection.
Implementieren einer Sammlung von Schlüssel-Wert-Paaren
Mit der Dictionary<TKey,TValue> generischen Auflistung können Sie mithilfe des Schlüssels der einzelnen Elemente auf Elemente in einer Auflistung zugreifen. Jede Ergänzung zum Wörterbuch besteht aus einem Wert und dem zugeordneten Schlüssel. Das Abrufen eines Werts mithilfe des Schlüssels ist schnell, da die Dictionary
Klasse als Hashtabelle implementiert wird.
Das folgende Beispiel erstellt eine Dictionary
-Auflistung und durchläuft das Wörterbuch unter Verwendung einer For Each
-Anweisung.
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
Um stattdessen einen Sammlungsinitialisierer zum Erstellen der Dictionary
Auflistung zu verwenden, 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
Im folgenden Beispiel werden die ContainsKey Methode und die Item[] Eigenschaft von Dictionary
verwendet, um ein Element schnell anhand eines Schlüssels zu finden. Die Eigenschaft Item
ermöglicht Ihnen, mithilfe des elements
-Codes in Visual Basic auf ein Element in der elements(symbol)
-Sammlung zuzugreifen.
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
Im folgenden Beispiel wird stattdessen die TryGetValue Methode verwendet, um ein Element nach Schlüssel schnell zu finden.
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
Verwenden von LINQ zum Zugriff auf eine Sammlung
LINQ (Language-Integrated Query) kann für den Zugriff auf Sammlungen verwendet werden. LINQ-Abfragen bieten Filter-, Sortier- und Gruppierungsfunktionen. Weitere Informationen finden Sie unter "Erste Schritte mit LINQ" in Visual Basic.
Im folgenden Beispiel wird eine LINQ-Abfrage gegenüber einer generischen List
ausgeführt. 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
Sortieren einer Auflistung
Im folgenden Beispiel wird eine Prozedur zum Sortieren einer Auflistung veranschaulicht. Im Beispiel werden Instanzen der Car
Klasse, die in einer List<T> gespeichert sind, sortiert. Die Car
Klasse implementiert die IComparable<T> Schnittstelle, die erfordert, dass die CompareTo Methode implementiert wird.
Jeder Aufruf der Methode führt einen einzelnen Vergleich aus, der für die CompareTo Sortierung verwendet wird. Vom Benutzer geschriebener 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 Null, wenn sie gleich sind. Auf diese Weise können Sie im Code die Kriterien für größer als, kleiner als und gleich definieren.
In der ListCars
Methode sortiert die cars.Sort()
Anweisung die Liste. Dieser Aufruf der Methode Sort von List<T> bewirkt, dass die Methode CompareTo
automatisch für die Objekte Car
in List
aufgerufen wird.
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
Definieren einer benutzerdefinierten Auflistung
Sie können eine Sammlung definieren, indem Sie die IEnumerable<T> oder IEnumerable Schnittstelle implementieren. Weitere Informationen finden Sie unter Enumerating a Collection.
Obwohl Sie eine benutzerdefinierte Auflistung definieren können, ist es in der Regel besser, stattdessen die Auflistungen zu verwenden, die im .NET Framework enthalten sind und im Abschnitt Arten von Auflistungen weiter oben in diesem Thema beschrieben werden.
Im folgenden Beispiel wird eine benutzerdefinierte Auflistungsklasse mit dem Namen definiert AllColors
. Diese Klasse implementiert die IEnumerable Schnittstelle, die erfordert, dass die GetEnumerator Methode implementiert wird.
Die GetEnumerator
Methode gibt eine Instanz der ColorEnumerator
Klasse zurück.
ColorEnumerator
implementiert die IEnumerator Schnittstelle, die erfordert, dass die Current Eigenschaft, MoveNext Methode und Reset Methode 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
Iteratoren
Ein Iterator wird verwendet, um eine benutzerdefinierte Iteration über eine Auflistung durchzuführen. Ein Iterator kann eine Methode oder ein get
Accessor sein. Ein Iterator verwendet eine Yield-Anweisung , um jedes Element der Auflistung einzeln zurückzugeben.
Sie rufen einen Iterator mit einer For Each... Next-Anweisung . Jede Iteration der For Each
Schleife ruft den Iterator auf. Wenn eine Yield
Anweisung im Iterator erreicht wird, wird ein Ausdruck zurückgegeben, und die aktuelle Position im Code wird beibehalten. Die Ausführung wird von diesem Speicherort neu gestartet, wenn der Iterator das nächste Mal aufgerufen wird.
Weitere Informationen finden Sie unter Iterators (Visual Basic).
Im folgenden Beispiel wird eine Iteratormethode verwendet. Die Iteratormethode weist eine Yield
-Anweisung auf, die sich in einer For...Next-Schleife befindet. In der ListEvenNumbers
Methode erstellt jede Iteration des For Each
Anweisungstexts einen Aufruf der Iterator-Methode, die mit der nächsten Yield
Anweisung fortfährt.
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
Siehe auch
- Auflistungsinitialisierer
- Programmierkonzepte (Visual Basic)
- Option Strict-Anweisung
- LINQ to Objects (Visual Basic)
- Parallel LINQ (PLINQ)
- Sammlungen und Datenstrukturen
- Auswählen einer Sammlungsklasse
- Vergleiche und Sortierungen innerhalb von Sammlungen
- Gründe für die Verwendung generischer Sammlungen