Collections

Collections

Inhaltszusammenfassung

In diesem Tutorial geht es um Listen. Der Vorteil von Listen ist, dass man die Länge nicht von Anfang an kennen muss wie beim Array. Listen sind dynamisch und können jederzeit länger oder kürzer werden. Dies wird hier anhand eines Beispiels erklärt.


Durchführung

Gehen wir von folgendem Code aus, worin wir später unsere Listen verwenden:

class Program
{
static void Main(string[] args)
{
Car car1 = new Car();
car1.Marke = "Oldsmobile";
car1.Model = "Cutlas Supreme";

Car car2 = new Car();
car2.Marke = "Geo";
car2.Model = "Prism";

Book b1 = new Book();
b1.Author = "Robert Tabor";
b1.Title = "Microsoft .NET XML Web Services";
b1.ISBN = "0-000-00000-0";



}
}

class Car
{
public string Marke { get; set; }
public string Model { get; set; }
}

class Book
{
public string Title { get; set; }
public string Author { get; set; }
public string ISBN { get; set; }
}

ArrayList

Fangen wir mit den ArrayListen an. Sie haben eine dynamische Größe und besitzen Methoden wie Sort und Remove, die sehr hilfreich sind. Eine Liste erstellt man wie ein neues Objekt. ArrayList bietet eine Funktion namens "Add" zum Hinzufügen von Werten und "Remove" zum Löschen. Beim Array brauchte man dazu einen Index, aber Listen brauchen so etwas nicht. Die Add Methode hängt, wie bei einer Kette, das Element immer am Ende dazu. Die Remove Methode findet das übergebene Objekt in der Liste und löscht es. Der Nachteil von ArrayList ist, dass alle Variablen, egal von welchem Datentyp gespeichert werden können, das heißt, eine ArrayList ist eigentlich einfach ein Behälter von allen möglichen Objekten. Dies kann ein Nachteil sein, wenn man zum Beispiel eine Liste von Autos hat und sich unabsichtlich ein Buch dazu gehängt hat. Sehen wir uns das in einem Beispiel an:

// ArrayLists haben eine dynamische Größe
// coole Features wie Sortieren, Entfernen von Elementen
ArrayList myArrayList = new ArrayList();
myArrayList.Add(car1);
myArrayList.Add(car2);
myArrayList.Add(b1);

foreach (Car car in myArrayList)
{
Console.WriteLine(car.Marke);
}

Dies wirft einen Fehler, da ein Buch nicht zu einem Auto werden kann. Zum Entfernen von Werten in einer Liste benutzt man die Remove Methode. Danach würde unser Code so aussehen:

// ArrayLists haben eine dynamische Größe
// coole features wie sortieren, entfernen von elementen
ArrayList myArrayList = new ArrayList();
myArrayList.Add(car1);
myArrayList.Add(car2);
myArrayList.Add(b1);
myArrayList.Remove(b1);

foreach (Car car in myArrayList)
{
Console.WriteLine(car.Marke);
}

List<T>

Das "T" steht für den Datentyp. Dies ermöglicht es eine Liste von einem bestimmten Datentyp zu erstellen. Es wird vermieden, dass die Liste eine Mischung aus mehreren Datentypen ist. Die List<T> besitzt die gleichen Methoden wie die ArrayList. Der größte Unterschied ist, dass die List von nur einem Datentyp ist und nicht eine Mischung wie bei der ArrayList. Unser vorher benutztes Beispiel würde mit einer List folgendermaßen aussehen:

// List<T>
List<Car> myList = new List<Car>();
myList.Add(car1);
myList.Add(car2);
//myList.Add(b1);
foreach (Car car in myList)
{
Console.WriteLine(car.Model);
}

Beachte: Das Hinzufügen eines Buches würde einen Fehler werfen!


Dictionary<TKey, TValue>

Ein Dictionary ist, wie das Wort schon sagt, wie ein Wörterbuch. Es speichert Werte, über die man mittels eines einzigartigen Schlüssels zugreifen kann. Müsste man in einer Liste zum Beispiel nach einem bestimmten Auto mit einer Kenntafel suchen, müssten man jedes Element in der Liste durchgehen und vergleichen. Das Dictionary vereinfacht dies. Die Initialisierung einer Liste von einem bestimmten Datentyp wurde vorher schon besprochen. Die Initialisierung eines Dictionary sagt, welchen Datentyp der Schlüssel hat und welchen der Wert selbst. Sonst schaut die Initialisierung des Dictionary ähnlich dessen der Liste aus. Wie vorher erwähnt, soll der Schlüssel einzigartig sein, aber unser Auto-Objekt besitzt nur einen Hersteller und ein Model, die nicht einzigartig sind. Fügen wir deswegen eine neue Property in der Car-Klasse ein, namens VIN und geben unseren Car-variablen den VIN "A1" und Car2 bekommt den VIN "B2". Schauen wir uns das vorher erklärte nun an einem Beispiel an:

// Dictionary<TKey, TValue>
Dictionary<string, Car> myDicionary = new Dictionary<string, Car>();

myDicionary.Add(car1.VIN, car1);
myDicionary.Add(car2.VIN, car2);

Console.WriteLine(myDicionary["B2"].Marke);

Der Zugriff auf einen Wert in dem Dictionary erfolgt wie bei einem Array, aber statt einem Index verwendet man den Schlüssel. Das Rückgabeobjekt ist ein Auto und deshalb ist es möglich, die Variablen eines Autos nun abzurufen.


Initializer

Bei dem Thema "Array" wurde schon angesprochen, wie man ein Array mit Werten in einer Zeile anlegt. Zur Erinnerung, das sah folgendermaßen aus:

string[] names = { "Bob", "Steve", "Brian", "Chuck" };

Dasselbe Prinzip funktioniert auch beim Erstellen eines neuen Objektes:

// Object initializer
// No need for a constructor
Car c1 = new Car() { Marke = "BMW", Model = "750li", VIN = "C3" };
Car c2 = new Car() { Marke = "Toyota", Model = "4runner", VIN = "D4" };

Somit könnte man das Erstellen eines neuen Objektes und die Erstellung einer Liste davon, in einem Statement zusammenpacken. Manche Personen würden das unübersichtlich finden, während andere Personen diese Variante vorziehen, da es Zeilen an Code erspart.

// Collection initializer
List<Car> myList1 = new List<Car>() {
new Car { Marke = "Oldsmobile", Model = "Cutlas Supreme", VIN = "E5"},
new Car { Marke = "Nissan", Model = "Altima", VIN = "F6"}
};

Vollständiger Programmcode

class Program
{
static void Main(string[] args)
{
Car car1 = new Car();
car1.Marke = "Oldsmobile";
car1.Model = "Cutlas Supreme";
car1.VIN = "A1";

Car car2 = new Car();
car2.Marke = "Geo";
car2.Model = "Prism";
car2.VIN = "B2";

Book b1 = new Book();
b1.Author = "Robert Tabor";
b1.Title = "Microsoft .NET XML Web Services";
b1.ISBN = "0-000-00000-0";


// ArrayLists haben eine dynamische Größe
// coole features wie sortieren, entfernen von elementen
ArrayList myArrayList = new ArrayList();
myArrayList.Add(car1);
myArrayList.Add(car2);
myArrayList.Add(b1);
myArrayList.Remove(b1);

foreach (Car car in myArrayList)
{
Console.WriteLine(car.Marke);
}


// List<T>
List<Car> myList = new List<Car>();
myList.Add(car1);
myList.Add(car2);
//myList.Add(b1);
foreach (Car car in myList)
{
Console.WriteLine(car.Model);
}



// Dictionary<TKey, TValue>
Dictionary<string, Car> myDicionary = new Dictionary<string, Car>();

myDicionary.Add(car1.VIN, car1);
myDicionary.Add(car2.VIN, car2);

Console.WriteLine(myDicionary["B2"].Marke);


string[] names = { "Bob", "Steve", "Brian", "Chuck" };

// Object initializer
// No need for a constructor
Car c1 = new Car() { Marke = "BMW", Model = "750li", VIN = "C3" };
Car c2 = new Car() { Marke = "Toyota", Model = "4runner", VIN = "D4" };


// Collection initializer
List<Car> myList1 = new List<Car>() {
new Car { Marke = "Oldsmobile", Model = "Cutlas Supreme", VIN = "E5"},
new Car { Marke = "Nissan", Model = "Altima", VIN = "F6"}
};


Console.ReadLine();
}
}

class Car
{
public string VIN { get; set; }
public string Marke { get; set; }
public string Model { get; set; }
}

class Book
{
public string Title { get; set; }
public string Author { get; set; }
public string ISBN { get; set; }
}