![\"Die](\"..\/fileadmin\/_temp_\/2021_03\/pic_268_001.png\")
<\/p>\nDer Unterschied zwischen generischen Auflistungen und nicht-generischen Auflistungen ist, dass Sie für die Elemente einer generischen Auflistung einen konkreten Datentyp vorgeben – das nennt man auch stark typisiert. Bei nicht-generischen Auflistungen nutzen Sie den Objekttyp Object und können somit Werte verschiedener Typen hinzufügen. Dieser Artikel stellt die Grundlagen zu generischen Auflistungsklassen vor und erläutert ihre Funktionsweise.<\/b><\/p>\nHinweis zu den Beispielen<\/h2>\n
Die Beispiele dieses Artikels haben wir in LINQPad5 erstellt und ausprobiert. Das ist eine schnellere Möglichkeit als ein Visual Studio Projekt zu erstellen, das Sie für jeden Test neu kompilieren und starten müssen. Weitere Infos zu LINQPad5 finden Sie beispielsweise im Artikel LINQPad: LINQ, C# und VB einfach ausprobieren <\/b>(www.datenbankentwickler.net\/100<\/b>). Wir verwenden hier unter Language <\/b>den Wert VB Program <\/b>und rufen unsere Beispielprozeduren jeweils von der Hauptprozedur Sub Main <\/b>auf.<\/p>\nGenerische Auflistungen<\/h2>\n
Eine generische Auflistung erkennen Sie primär daran, dass Sie diese mit der Angabe des Datentyps für die enthaltenen Werte deklarieren und initialisieren. Dazu verwenden wir das Schlüsselwort Of <\/b>zusammen mit dem gewünschten Datentyp. Die gängigen generischen Auflistungen werden in den Namespaces System.Collections.Generic <\/b>und System.Collections.ObjectModel <\/b>aufgeführt.<\/p>\n
Zu den nicht-generischen Auflistungen gibt es in den meisten Fällen ein Pendant unter den generischen Auflistungen. Diese sind leider nicht entsprechend benannt. So ist das generische Gegenstück zu der nicht-generischen Auflistungsklasse HashTable <\/b>die Dictionary<\/b>-Klasse und List <\/b>ist das Pendant zu ArrayList<\/b>.<\/p>\n
Es gibt aber auch generische Auflistungsklassen ohne nicht-generische Entsprechung.<\/p>\n
Generische Auflistungen sind auch Klassen, allerdings solche, die das Speichern einer Reihe anderer Objekte erlauben. .NET bietet einige Auflistungsklassen für verschiedene Anwendungszwecke an. Sie sind aber nicht einfach nur Sammlungen von Daten, sondern bieten auch die Infrastruktur an, um diese Daten an verschiedenen Stellen auf spezielle Art zu nutzen – zum Beispiel als Datenquelle von Steuerelementen unter WPF. Die Auflistungsklassen implementieren verschiedene Interfaces, die Eigenschaften, Methoden und Ereignisse für die unterschiedlichen Zwecke vorsehen. Welche Interfaces eine Collection implementiert, können Sie im Objektkatalog von Visual Studio nachsehen (Strg + Alt + J<\/b>).<\/p>\n
Bild 1 zeigt die Basistypen beziehungsweise Schnittstellen der Auflistungsklasse List(Of T<\/b>), wobei T <\/b>dem Datentyp der Elemente der Auflistung entspricht. Im Objektkatalog finden Sie auch die Eigenschaften, Methoden und Ereignisse der jeweiligen Auflistungen.<\/p>\n
<\/p>\n
Bild 1: Die List(Of T)-Auflistungsklasse im Objektkatalog<\/span><\/b><\/p>\n Die List(Of T)<\/b>-Auflistungsklasse implementiert beispielsweise die folgenden Interfaces:<\/p>\n In diesem Artikel stellen wir verschiedene generische Auflistungsklassen vor:<\/p>\n Die List(Of T)<\/b>-Auflistungsklasse ist das generische Pendant zur ArrayList<\/b>-Auflistungsklasse, das heißt, dass für Ihre Elemente exakt festgelegt wird, welchen Typ diese aufweisen. Das nennt sich auch stark typisiert.<\/p>\n In den folgenden Beispielen wollen wir mit einer kleinen Beispielklasse namens Produkt arbeiten, die wir wie folgt deklarieren:<\/p>\n Ein paar Beispielobjekte auf Basis dieser Klasse erstellen wir mit den folgenden Anweisungen:<\/p>\n Bei der Deklaration einer generischen Auflistungsklasse geben Sie als Parameter das Schlüsselwort Of <\/b>und den Typ des enthaltenen Objekttyps an. Für unser Beispiel verwenden wir eine Auflistung namens Produkte <\/b>mit dem Typ Produkt<\/b>. Die Deklarationszeile sieht so aus:<\/p>\n Wenn Sie die Initialisierung separat gestalten wollen, gelingt dies so:<\/p>\n Sie können natürlich auch beides in einer Zeile unterbringen:<\/p>\n Die oben erstellten Objekte fügen wir mit der Add<\/b>-Methode zur Auflistungsklasse Produkte <\/b>hinzu:<\/p>\n Wenn Sie die Liste nicht etwa per Entity Framework aus einer DbSet<\/b>-Auflistung füllen wollen, können Sie den sogenannten Collection Initializer <\/b>nutzen. Dabei geben Sie hinter der eigentlichen Initialisierung das From<\/b>-Schlüsselwort und dann in geschweiften Klammern eine Liste der einzufügenden Elemente an:<\/p>\n Die einfachste Methode, die Elemente einer generischen Auflistungsklasse zu durchlaufen, ist die For Each<\/b>-Schleife. Sie verwenden darin eine Variable, welche das jeweilige Element aufnehmen soll und die zu durchlaufende Auflistungsklasse. Die Elemente der soeben angelegten Auflistungsklasse können Sie wie folgt durchlaufen und beispielsweise im Ausgabe-Bereich ausgeben – ausgehend von einer wie oben beschrieben erstellten Auflistung namens Produkte<\/b>:<\/p>\n Das Ergebnis lautet:<\/p>\n Die Elemente einer List(Of T)<\/b>-Auflistungsklasse können Sie genau wie bei der ArrayList-<\/b>Auflistungsklasse auch über die Item<\/b>-Eigenschaft referenzieren. Dazu können Sie beispielsweise den Index als Parameter verwenden. Wichtig ist, dass Sie damit ein Objekt des jeweiligen Typs, hier Produkt<\/b>, zurückbekommen:<\/p>\n Da Item <\/b>die Standardeigenschaft ist, können Sie sie auch weglassen und direkt den Index angeben:<\/p>\n Sie können auch direkt über das Item<\/b>-Element auf die Eigenschaften zugreifen:<\/p>\n Damit können wir sowohl auf einzelne Elemente innerhalb einer Schleife zugreifen, nämlich For…Next<\/b>:<\/p>\n Mit der Add<\/b>-Methode fügen wir Elemente immer hinten an die Liste an. Sie können aber auch Elemente mitten in der ArrayList<\/b>-Auflistungsklasse anfügen. Dazu nutzen Sie die Insert<\/b>– oder die InsertRange<\/b>-Methode. Im folgenden Beispiel fügen wir ein Element mit Add <\/b>an, dann eines mit Insert <\/b>vor diesem Element an der mit dem ersten Parameter angegebenen Position 0<\/b>.<\/p>\n Die Elemente des Arrays arr <\/b>fügen wir dann zwischen diese beiden Elemente an Position 1 <\/b>ein:<\/p>\n Mit der AddRange<\/b>-Methode können Sie auch mehrerer Elemente gleichzeitig hinzufügen. Voraussetzung dafür ist, dass die hinzuzufügenden Elemente sich ebenfalls in einer generischen Auflistung befinden. Im folgenden Beispiel erstellen wir eine Zielauflistung und eine, aus der die Elemente zur Zielauflistung hinzugefügt werden – in diesem Fall auch eine des Typs List(Of T)<\/b> namens ProdukteZumEinfuegen<\/b>. Dieser fügen wir zwei Elemente hinzu. Dann fügen wir mit der InsertRange<\/b>-Methode die Elemente aus ProdukteZumEinfuegen <\/b>zur Auflistung Produkte hinzu – und zwar an der Index<\/b>-Position 0<\/b>:<\/p>\n Um einzelne oder mehrere Elemente wieder zu entfernen, können Sie drei Möglichkeiten nutzen:<\/p>\n Im folgenden Beispiel löschen wir nacheinander alle zuvor hinzugefügten Elemente wieder mit den drei Methoden Remove<\/b>, RemoveAt <\/b>und RemoveRange<\/b>.<\/p>\n RemoveAt <\/b>entfernt das Element mit dem als Parameter angegebenen Index:<\/p>\n Remove <\/b>entfernt ein Element, das mit dem zu entfernenden Produkt übereinstimmt – zu ermitteln beispielsweise über die Produkte<\/b>-Auflistung:<\/p>\n RemoveRange <\/b>entfernt vom als ersten Parameter angegebenen Index aus die mit dem zweiten Parameter angegebene Menge aus der Auflistung:<\/p>\n Gegenüber der ArrayList <\/b>liefert List(Of T) <\/b>noch eine weitere Methode zum Entfernen, nämlich RemoveAll<\/b>. Mit dieser können Sie etwa wie folgt Elemente nach bestimmten Kriterien entfernen:<\/p>\n Fehlt noch der Befehl, um eine generische Auflistungsklasse zu leeren. Das erledigen wir mit der Clear<\/b>-Methode:<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>\n
Beispiele für generische Auflistungsklassen<\/h2>\n
\n
Die List(Of T)-Auflistungsklasse<\/h2>\n
Public Class<\/span> Produkt\r\n Public <\/span>Produktname As String<\/span>\r\n Public <\/span>Einzelpreis As Decimal<\/span>\r\nEnd Class<\/span><\/pre>\nDim <\/span>Produkt1 As <\/span>New<\/span> Produkt With<\/span> {.Produktname = \"Access im Unternehmen\", .Einzelpreis = 124}\r\nDim <\/span>Produkt2 As <\/span>New<\/span> Produkt With<\/span> {.Produktname = \"Access [Basics]\", .Einzelpreis = 69}\r\nDim <\/span>Produkt3 As <\/span>New<\/span> Produkt With<\/span> {.Produktname = \"Datenbankentwickler\", .Einzelpreis = 129}<\/pre>\nGenerische Auflistungsklasse deklarieren und initialisieren<\/h2>\n
Dim <\/span>Produkte As <\/span>List(Of Produkt)<\/pre>\nProdukte = New<\/span> List(Of Produkt)<\/pre>\nDim <\/span>Produkte As <\/span>New<\/span> List(Of Produkt)<\/pre>\nElemente zu einer generischen Auflistungsklasse hinzufügen<\/h2>\n
With<\/span> Produkte\r\n .Add(Produkt1)\r\n .Add(Produkt2)\r\n .Add(Produkt3)\r\nEnd With<\/span><\/pre>\nGenerische Auflistungsklasse schnell füllen per Collection Initializer<\/h2>\n
Dim <\/span>Produkt1 As <\/span>New<\/span> Produkt With<\/span> {.Produktname = \"Access im Unternehmen\", .Einzelpreis = 124}\r\nDim <\/span>Produkt2 As <\/span>New<\/span> Produkt With<\/span> {.Produktname = \"Access [Basics]\", .Einzelpreis = 69}\r\nDim <\/span>Produkt3 As <\/span>New<\/span> Produkt With<\/span> {.Produktname = \"Datenbankentwickler\", .Einzelpreis = 129}\r\nDim <\/span>Produkte As <\/span>New<\/span> List(Of Produkt) From {Produkt1, Produkt2, Produkt3}\r\nDebug.Print<\/span>(\"Anzahl Produkte: \" + Produkte.Count.ToString) <\/pre>\nElemente einer generischen Auflistungsklasse mit For Each durchlaufen<\/h2>\n
For Each Produkt In Produkte\r\n Debug.Print<\/span>(Produkt.Produktname + \" \" + Produkt.Einzelpreis.ToString)\r\nNext<\/span> Produkt<\/pre>\nAccess im Unternehmen 124\r\nAccess [Basics] 69\r\nDatenbankentwickler 129<\/pre>\n
Auf Elemente einer generischen Auflistungsklasse per Index zugreifen<\/h2>\n
Dim <\/span>Produkt4 As <\/span>Produkt\r\nProdukt4 = Produkte.Item(0)\r\nDebug.Print<\/span>(Produkt4.Produktname)<\/pre>\nProdukt4 = Produkte(0)<\/pre>\n
Dim <\/span>strProduktname As String<\/span>\r\nstrProduktname = Produkte(0).Produktname\r\nDebug.Print<\/span>(strProduktname)<\/pre>\nElemente einer generischen Auflistungsklasse mit For…Next durchlaufen<\/h2>\n
Dim <\/span>i As Integer<\/span>\r\nFor i = 0 To Produkte.Count - 1\r\n Debug.Print<\/span>(Produkte(i).Produktname)\r\nNext<\/span> i<\/pre>\nElemente an bestimmter Stelle einfügen<\/h2>\n
Produkte.Insert(1, Produkt3)<\/pre>\n
Mehrere Elemente an bestimmter Stelle einfügen<\/h2>\n
Dim <\/span>Produkte As <\/span>New<\/span> List(Of Produkt)\r\nDim <\/span>ProdukteZumEinfuegen As <\/span>New<\/span> List(Of Produkt)\r\nWith<\/span> Produkte\r\n .Add(Produkt1)\r\nEnd With<\/span>\r\nWith<\/span> ProdukteZumEinfuegen\r\n .Add(Produkt2)\r\n .Add(Produkt3)\r\nEnd With<\/span>\r\nProdukte.InsertRange(0, ProdukteZumEinfuegen)<\/pre>\nElemente aus generischen Auflistungsklassen entfernen<\/h2>\n
\n
Produkte.RemoveAt(0)<\/pre>\n
Produkte.Remove(Produkte(0))<\/pre>\n
Produkte.RemoveRange(0,2)<\/pre>\n
Produkte.RemoveAll(Function(Produkt) Produkt.Produktname.StartsWith(\"A\"))<\/pre>\n
Generische Auflistungsklassen leeren<\/h2>\n
... ''Produkt1 bis Produkt3 erstellen\r\nDim <\/span>Produkte As <\/span>New<\/span> List(Of Produkt)\r\nWith<\/span> Produkte\r\n .Add(Produkt1)\r\n .Add(Produkt2)\r\n .Add(Produkt3)\r\nEnd With<\/span>\r\nProdukte.Clear<\/pre>\nElemente der generischen Auflistungsklasse durchsuchen<\/h2>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t