Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 6. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Das Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Strukturen und Enumerationen
7 Fehlerbehandlung und Debugging
8 Auflistungsklassen (Collections)
9 Generics – Generische Datentypen
10 Weitere C#-Sprachfeatures
11 LINQ
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 XML
15 Multithreading und die Task Parallel Library (TPL)
16 Einige wichtige .NET-Klassen
17 Projektmanagement und Visual Studio 2012
18 Einführung in die WPF und XAML
19 WPF-Layout-Container
20 Fenster in der WPF
21 WPF-Steuerelemente
22 Elementbindungen
23 Konzepte von WPF
24 Datenbindung
25 Weitere Möglichkeiten der Datenbindung
26 Dependency Properties
27 Ereignisse in der WPF
28 WPF-Commands
29 Benutzerdefinierte Controls
30 2D-Grafik
31 ADO.NET – Verbindungsorientierte Objekte
32 ADO.NET – Das Command-Objekt
33 ADO.NET – Der SqlDataAdapter
34 ADO.NET – Daten im lokalen Speicher
35 ADO.NET – Aktualisieren der Datenbank
36 Stark typisierte DataSets
37 Einführung in das ADO.NET Entity Framework
38 Datenabfragen des Entity Data Models (EDM)
39 Entitätsaktualisierung und Zustandsverwaltung
40 Konflikte behandeln
41 Plain Old CLR Objects (POCOs)
Stichwort

Download:
- Beispiele, ca. 62,4 MB

Buch bestellen
Ihre Meinung?

Spacer
Visual C# 2012 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2012

Visual C# 2012
Rheinwerk Computing
1402 S., 6., aktualisierte und erweiterte Auflage 2013, geb., mit DVD
49,90 Euro, ISBN 978-3-8362-1997-6
Pfeil 8 Auflistungsklassen (Collections)
Pfeil 8.1 Grundlagen
Pfeil 8.2 Collections im Namespace »System.Collections«
Pfeil 8.2.1 Die elementaren Schnittstellen der Auflistungsklassen
Pfeil 8.3 Die Klasse »ArrayList«
Pfeil 8.3.1 Einträge hinzufügen
Pfeil 8.3.2 Datenaustausch zwischen einem Array und einer »ArrayList«
Pfeil 8.3.3 Die Elemente einer »ArrayList« sortieren
Pfeil 8.3.4 Sortieren von Arrays mit »ArrayList.Adapter«
Pfeil 8.4 Die Klasse »Hashtable«
Pfeil 8.4.1 Methoden und Eigenschaften der Schnittstelle »IDictionary«
Pfeil 8.4.2 Beispielprogramm zur Klasse »Hashtable«
Pfeil 8.5 Die Klassen »Queue« und »Stack«
Pfeil 8.5.1 Die Klasse »Stack«
Pfeil 8.5.2 Die Klasse »Queue«
Pfeil 8.6 Eigene Auflistungen mit »yield« durchlaufen

Galileo Computing - Zum Seitenanfang

8.3 Die Klasse »ArrayList«Zur nächsten Überschrift

ArrayList gehört zu den Klassen, die das Interface IList implementieren. Ein Objekt vom Typ ArrayList hat standardmäßig eine Kapazität von null Elementen. Fügen Sie das erste Element hinzu, wird die Kapazität auf vier Elemente erhöht. Wird das fünfte Element hinzugefügt, verdoppelt sich automatisch die Kapazität auf acht Elemente. Grundsätzlich wird die Kapazität immer verdoppelt, wenn versucht wird, ein Element mehr hinzuzufügen, als es die aktuelle Kapazität erlaubt. Dabei werden die ArrayList-Elemente im Speicher umgeschichtet, was einen Leistungsverlust zur Folge hat, der umso größer ist, je mehr Elemente sich bereits in der ArrayList befinden.

Sie sollten daher von Anfang an der ArrayList eine angemessene Kapazität zugestehen. Am besten ist es, einfach den parametrisierten Konstruktor aufzurufen und diesem die gewünschte Anfangskapazität mitzuteilen. Eine weitere Möglichkeit bietet auch die Eigenschaft Capacity.


Galileo Computing - Zum Seitenanfang

8.3.1 Einträge hinzufügenZur nächsten ÜberschriftZur vorigen Überschrift

Mit der Methode Add lassen sich Objekte einer ArrayList-Instanz hinzufügen. Das erste Element wird dann den Index »0« haben, das zweite den Index »1« usw. Sie haben mit der Add-Methode keinen Einfluss darauf, an welcher Position der Liste das Objekt hinzugefügt wird, denn es wird immer an das Listenende angehängt. Wollen Sie wissen, welchen Index ein hinzugefügtes Objekt erhalten hat, brauchen Sie nur den Rückgabewert der Add-Methode auszuwerten.

ArrayList liste = new ArrayList();
int index = liste.Add("Werner");

Die Add-Methode ist sehr typflexibel und definiert einen Parameter vom Typ Object. Sie können also alle Typen kunterbunt in die Liste packen, vom String über einen booleschen Wert, von einem Button- bis hin zu einem Circle-Objekt. Spätestens dann, wenn Sie die einzelnen Elemente auswerten wollen, werden Sie jedoch in Schwierigkeiten geraten, falls Sie nicht exakt wissen, welcher Typ sich hinter einem bestimmten Listenindex verbirgt. Genau das ist auch der Nachteil der ArrayList.

Über die Methode Add hinaus bietet ArrayList mit AddRange eine weitere, ähnliche Methode an, der Sie auch ein herkömmliches Array übergeben können:

ArrayList liste = new ArrayList();
int[] array = {0, 10, 22, 9, 45};
liste.AddRange(array);

Listing 8.1 Die Methode »AddRange« der Klasse »ArrayList«

Liegt das Array schon bei der Instanziierung von ArrayList vor, kann das Array auch direkt dem Konstruktor übergeben werden:

ArrayList arr = new ArrayList(intArr);

Collection-Initialisierer

Eine weitere Möglichkeit, einer ArrayList Elemente hinzuzufügen, sind Auflistungs-Initialisierer. Mithilfe von Collection-Initialisierern kann man bei der Initialisierung eines Auflistungs-Objekts elegant Elemente hinzufügen. Man verwendet geschweifte Klammern, in denen die einzelnen Elemente durch Kommata voneinander getrennt sind – was dann beispielsweise wie folgt aussieht:

ArrayList liste = new ArrayList() {"Aachen", "Bonn", "Köln", "Düsseldorf" };

Collection-Initialisierer verringern den Codierungsaufwand, da nicht immer wieder die Add-Methode aufgerufen werden muss.

Einträge aus einer »ArrayList« löschen

Mit der Methode Clear können alle Elemente aus der ArrayList gelöscht werden. Die ArrayList wird danach, obwohl sie leer ist, ihre ursprüngliche Kapazität beibehalten, sie schrumpft also nicht.

Löschen Sie einzelne Elemente, bieten sich die Methoden Remove und RemoveAt an. Remove erwartet das zu löschende Objekt, RemoveAt den Index des zu löschenden Objekts. Beim Löschen ist ein ganz besonderes Verhalten der IList-basierten Auflistungen zu erkennen, das wir uns nun in einem Beispiel ansehen wollen.

// Beispiel: ..\Kapitel 8\ArrayListSample

using System;
using System.Collections;

class Program {

static void Main(string[] args) {
ArrayList liste = new ArrayList {"Peter", "Andreas", "Conie", "Michael",
"Gerd", "Freddy"};
PrintListe(liste);
liste.Remove("Andreas");
Console.WriteLine("--- Element gelöscht ---");
PrintListe(liste);
Console.ReadLine();
}

// Ausgabe der Liste

static void PrintListe(IList liste) {
foreach (string item in liste)
Console.WriteLine("Index: {0,-3}{1}", liste.IndexOf(item), item);
}
}

Listing 8.2 Beispiel mit einer einfachen ArrayList

Beachten Sie bitte bei diesem und allen anderen Beispielen in diesem Kapitel, dass Sie den Namespace System.Collections mit using bekannt geben.

Die benutzerdefinierte Methode PrintListe sorgt für die Ausgabe der Elemente an der Konsole. Das Übergabeargument ist als Typ IList definiert. Daher kann der Methode jedes Objekt übergeben werden, das die Schnittstelle IList implementiert, beispielsweise ein herkömmliches Array – vorausgesetzt, es verwaltet Zeichenfolgen.

Nach dem Füllen der Auflistung wird der Inhalt an der Konsole ausgegeben. Neben der Zeichenfolge wird dabei auch noch der aktuelle Index, unter dem die Zeichenfolge eingetragen ist, angezeigt. Der aktuelle Index eines Elements lässt sich mit der Methode IndexOf unter Übergabe des Elements sehr einfach ermitteln.

Nach der Ausgabe der Liste wird das an zweiter Position (Index = 1) befindliche Element mit Remove aus der Auflistung gelöscht. Die Ausgabe der aktualisierten Liste beweist die weiter oben angedeutete typische Charakteristik der indexbasierten Collections: Der Index, den das aus der Liste gelöschte Element innehatte, bleibt nicht leer. Stattdessen verschieben sich alle nachfolgenden Elemente in der Weise, dass kein leerer Index zurückbleibt (siehe auch Abbildung 8.1).

Abbildung

Abbildung 8.1 Element aus der Auflistung löschen

Möchten Sie während eines Schleifendurchlaufs ein Element aus der Liste löschen, ist eine foreach-Schleife als Schleifenkonstrukt denkbar ungeeignet, denn die Methoden des Interfaces IEnumerator funktionieren nur dann, wenn sich die Liste während des Schleifendurchlaufs nicht verändert.

Sollte sich dasselbe Objekt mehrfach in der Liste befinden, wird nur das Objekt entfernt, das zuerst gefunden wird. Nehmen wir an, der Name Andreas würde auch noch unter Index = 6 zu finden sein, wird nur der Eintrag mit dem Index = 1 entfernt. Sie können doppelte Einträge in eine Liste vermeiden, wenn Sie vor dem Hinzufügen des Elements mit Contains prüfen, ob sich das Element eventuell bereits in der Liste befindet.

Eine Lösung in solchen Fällen ist die Verwendung der for- oder while-Schleife, z. B.:

for(int index = 0; index < liste .Count; index++) 
{
if( (string)liste[index] == "Andreas")
liste.RemoveAt(index);
}

Listing 8.3 Löschen eines ArrayList-Elements in einer Schleife

Auf ein Listenelement wird über seinen Index zugegriffen, indem der Index in eckige Klammern gesetzt wird. Da die Elemente als Object-Typen in die ArrayList eingetragen werden, ist eine Konvertierung in den passenden Typ notwendig, in unserem Code also in string.


Galileo Computing - Zum Seitenanfang

8.3.2 Datenaustausch zwischen einem Array und einer »ArrayList«Zur nächsten ÜberschriftZur vorigen Überschrift

Auflistungen zeichnen sich durch die beiden Interfaces IEnumerable und ICollection aus. Aus dem letztgenannten Interface stammt die Methode CopyTo, die es ermöglicht, die Einträge einer Auflistung in ein Array zu kopieren.

ArrayList liste = new ArrayList();
liste.Add("Anton");
liste.Add("Gustaf");
liste.Add("Fritz");
string[] arr = new string[10];
liste.CopyTo(arr, 3);

Listing 8.4 ArrayList-Elemente in ein Array kopieren

Der zweite Parameter von CopyTo gibt den Startindex im Array an, ab dem die Elemente der ArrayList in das Array kopiert werden. Das Array muss groß genug sein, um alle Elemente aufzunehmen, sonst wird eine Exception ausgelöst. Handelt es sich bei den zu kopierenden Einträgen um Objektreferenzen, werden nicht die Objekte, sondern nur die Referenzen kopiert. ArrayList überlädt CopyTo, so dass auch spezifizierte Teilbereiche der Liste kopiert werden können.


Galileo Computing - Zum Seitenanfang

8.3.3 Die Elemente einer »ArrayList« sortierenZur nächsten ÜberschriftZur vorigen Überschrift

Zum Sortieren der Mitglieder einer ArrayList dient die Methode Sort. Diese Methode ist mehrfach überladen. Wir wollen uns zunächst mit der parameterlosen Version beschäftigen.

Die parameterlose »Sort«-Methode

Um die Elemente einer ArrayList mit der parameterlosen Sort-Methode zu sortieren, müssen die Elemente das Interface IComparable unterstützen. Diese Schnittstelle beschreibt nur die Methode CompareTo:

public interface IComparable {
int CompareTo(object obj);
}

Eine Klasse, die IComparable implementiert, garantiert die Existenz der Methode CompareTo. Darauf ist die parameterlose Variante der Sort-Methode angewiesen. Aus der .NET-Dokumentation zu CompareTo können wir entnehmen, dass das Objekt, auf dem Sort aufgerufen wird, mit dem an den Parameter übergebenen Objekt verglichen wird. Als Resultat liefert der Methodenaufruf eines der drei folgenden Ergebnisse:

  • < 0, wenn das Objekt, auf dem die Methode aufgerufen wird, kleiner als das Objekt obj ist.
  • 0, wenn das Objekt, auf dem die Methode aufgerufen wird, gleich dem Objekt obj ist.
  • > 0, wenn das Objekt, auf dem die Methode aufgerufen wird, größer als das Objekt obj ist.

Die Regel, nach der im deutschsprachigen Raum eine Zeichenfolge sortiert wird, vergleicht die Zeichen unter Berücksichtigung der Groß- und Kleinschreibung wie folgt:

1 < 2 ... < a < A < b < B < c < C ... < y < Y < z < Z

Da die parameterlose Sort-Methode das Interface IComparable voraussetzt, sind alle Klassen, die diese Schnittstelle implementieren, ohne zusätzlichen Programmcode dazu geeignet, innerhalb einer ArrayList sortiert zu werden. Das trifft insbesondere auf die elementaren Datentypen wie string, int oder double zu. Somit ist es uns auch möglich, die Listenelemente aus dem Beispiel ArrayListSample durch den Aufruf von Sort unkompliziert sortieren zu lassen.

static void Main(string[] args) {
ArrayList liste = new ArrayList() {"Peter", "Andreas", "Conie",
"Michael", "Gerd", "Freddy"};
liste.Sort();

PrintListe(liste);
Console.ReadLine();
}

Listing 8.5 Sortieren einer ArrayList

Die Ausgabe der sortierten Liste sehen Sie in Abbildung 8.2.

Abbildung

Abbildung 8.2 Die mit der Methode »Sort()« sortierten Listenelemente

Eigene Klassen mit »IComparable«

Viele Klassen des .NET Frameworks implementieren die IComparable-Schnittstelle. Das folgende Beispielprogramm soll zeigen, wie Sie dieses Interface auch für eigene Klassen einsetzen können. Dabei werden wir der Einfachheit halber nur mit einer sehr einfachen Klasse arbeiten, die neben der Schnittstellenimplementierung nur einen Integer-Wert in der Eigenschaft Value beschreibt.

public class Demo : IComparable {
public int Value {get; set;}

public int CompareTo(object obj) {
if(obj == null) return 1;
Demo demo = obj as Demo;
if (demo != null) return Value.CompareTo(((Demo)obj).Value);
throw new ArgumentException("Object ist nicht vom Typ Demo");
}
}

Listing 8.6 Implementieren der Schnittstelle »IComparable«

Die Klasse Demo implementiert das Interface IComparable. Daher sind Objekte dieses Typs darauf vorbereitet, innerhalb einer ArrayList sortiert zu werden. Die Sortierreihenfolge soll sich am Inhalt des Felds Value orientieren. Da CompareTo den Parameter vom Typ Object definiert, müssen wir zwei besondere Situationen berücksichtigen:

  • An den Parameter obj wird null übergeben.
  • Da der Parameter vom Typ Object ist, könnte auch die Referenz auf ein Objekt übergeben werden, das nicht vom Typ Demo oder davon abgeleitet ist.

Daher überprüfen wir im ersten Schritt, ob die Übergabe an den Parameter null ist. Sollte das der Fall sein, wird die Methode unter Rückgabe des Wertes 1 verlassen. Sollte das Übergabeargument von null abweichen, wird im nächsten Schritt mit dem Operator as geprüft, ob es sich um ein Objekt vom Typ Demo handelt. Die Überprüfung mit as liefert null, falls es sich nicht um ein Demo-Objekt handelt.

Der konkrete Vergleich zwischen zwei Objekten vom Typ Demo ist sehr einfach. Da der Vergleich sich auf die Eigenschaft Value bezieht, die vom Typ Integer ist, können wir davon profitieren, dass Int32 selbst die Schnittstelle IComparable implementiert und somit auch die Methode CompareTo bereitstellt.

Generell sollten Sie die Methode CompareTo der Schnittstelle IComparable wie gezeigt implementieren, um gegen alle unzulässigen Aufrufe gewappnet zu sein und als robust zu gelten.

Natürlich wollen wir nun auch testen, ob wir unser Ziel erreicht haben. Dazu dient der folgende Code:

// Beispiel: ..\Kapitel 8\IComparableSample  

class Program {
static void Main(string[] args) {
Demo[] arr = new Demo[] { new Demo { Value = 56 }, new Demo{ Value = 72 },
new Demo { Value = 35 }, new Demo{ Value = 3 }};
ArrayList liste = new ArrayList();
liste.AddRange(arr);
liste.Sort();
foreach (Demo item in liste) {
Console.WriteLine("Index: {0}/Wert: {1}",liste.IndexOf(item), item.Value);
}
Console.ReadLine();
}
}

Listing 8.7 Sortieren von Demo-Objekten (siehe Listing 8.5)

An der Konsole werden die Werte der Felder in der Reihenfolge 3, 35, 56 und 72 ausgegeben. Der Vergleich und die anschließende Sortierung finden also wie erwartet statt.

Vergleichsklassen mit »IComparer«

Das Sortieren einer ArrayList mit der parameterlosen Sort-Methode gestattet nur, ein durch das Interface IComparable vorgeschriebenes Vergleichskriterium zu nutzen. Manchmal ist es jedoch erforderlich, unterschiedliche Sortierkriterien zu berücksichtigen. Nehmen wir zum Beispiel die Klasse Person, die die beiden Felder Name und City beschreibt:

class Person {
public string Name {get; set;}
public string City {get; set;}
}

Listing 8.8 Die Definition der Klasse »Person«

Würde die Klasse die Schnittstelle IComparable implementieren, müsste die Entscheidung getroffen werden, nach welchem Feld Objekte dieser Klasse sortiert werden können. Nun sollen beide Möglichkeiten angeboten werden: sowohl die Sortierung nach City als auch nach Name.

Die Lösung des Problems führt über die Bereitstellung sogenannter Vergleichsklassen, die die Schnittstelle IComparer implementieren. Jede Vergleichsklasse beschreibt genau ein Vergleichskriterium. Wollen wir einen bestimmten Objektvergleich erzwingen, müssen wir der Sort-Methode mitteilen, welche Vergleichsklasse dafür bestimmt ist. Dafür stehen uns zwei Überladungen zur Verfügung, denen die Referenz auf ein Objekt übergeben wird, das die Schnittstelle IComparer implementiert:

public virtual void Sort(IComparer);

public virtual void Sort(int, int, IComparer);

Mit der Überladung, die zwei Integer erwartet, können der Startindex und die Länge des zu sortierenden Bereichs festgelegt werden. Bei sehr großen Auflistungen steigert eine solche Bereichseingrenzung die Performance, da Sortiervorgänge immer sehr rechenintensiv sind.

Die Schnittstelle IComparer stellt die Methode Compare für den Vergleich zweier Objekte bereit:

int Compare(object x, object y);

Compare funktioniert ähnlich wie die weiter oben erörterte Methode CompareTo und gibt die folgenden Werte zurück:

  • < 0, wenn das erste Objekt kleiner als das zweite Objekt ist
  • 0, wenn das erste Objekt gleich dem zweiten Objekt ist
  • > 0, wenn das erste Objekt größer als das zweite Objekt ist

Für die Klasse Person wollen wir nun die beiden Vergleichsklassen NameComparer und CityComparer entwickeln, die gemäß unserer Anforderung die Schnittstelle IComparer implementieren und nach City bzw. Name sortieren.

// Vergleichsklasse – Kriterium City

class CityComparer : IComparer {
public int Compare(object x, object y) {

// Prüfen auf null-Übergabe

if(x == null && y == null) return 0;
if(x == null) return -1;
if(y == null) return 1;

// Typüberprüfung

if(x.GetType() != y.GetType())
throw new ArgumentException("Ungültiger Vergleich");

// Vergleich

return ((Person)x).City.CompareTo(((Person)y).City);
}
}

// Vergleichsklasse – Kriterium Name

class NameComparer : IComparer {
public int Compare(object x, object y) {

// Prüfen auf null-Übergabe

if(x == null && y == null) return 0;
if(x == null) return -1;
if(y == null) return 1;

// Typüberprüfung

if(x.GetType() != y.GetType())
throw new ArgumentException("Ungültiger Vergleich");

// Vergleich

return ((Person)x).Name.CompareTo(((Person)y).Name);
}
}

Listing 8.9 Vergleichsklassen für die Klasse »Person« aus Listing 8.8

Die Implementierung ähnelt der der Methode CompareTo. Zuerst sollte wieder ein Vergleich mit null durchgeführt werden und anschließend eine Prüfung, ob beide Parameter denselben Typ beschreiben oder zumindest einen vergleichbaren Typ besitzen. Sollte keine Bedingung zutreffen, kann der Vergleich der Objekte erfolgen. Dabei unterstützt uns die Klasse String, die selbst die IComparable-Schnittstelle implementiert und folglich die Methode CompareTo veröffentlicht.

Haben wir ein ArrayList-Objekt mit Person-Objekten gefüllt, steht es uns frei, welche Vergleichsklasse wir zur Sortierung der Objekte benutzen, denn beide sind auf dieselbe Schnittstelle zurückzuführen und gegenseitig austauschbar.

Natürlich können Sie auch jederzeit die Klasse Person um die Schnittstelle IComparer erweitern. Syntaktisch bereitet das zumindest bei einem erforderlichen Vergleichskriterium überhaupt kein Problem. Andererseits müssen Sie sich auch vor Augen halten, wie Sie die Sort-Methode aufrufen müssten:

liste.Sort(new Person());

Dieser Code suggeriert, dass wir es mit einem weiteren, neuen Person-Objekt zu tun haben, obwohl wir das Objekt doch eigentlich nur dazu missbrauchen, das Vergleichskriterium der Sort-Methode anzugeben. Ähnlich schlecht lesbarer und interpretierbarer Code wäre das Resultat, wenn wir mit

liste.Sort(person1);

irgendein existentes Person-Objekt übergeben. Daher sollten Sie von dieser Codeimplementierung Abstand nehmen.

Sehen wir uns nun das Beispielprogramm an, in dem die oben beschriebenen Vergleichskriterien benutzt werden.

// Beispiel: ..\Kapitel 8\IComparerSample

class Program {
static void Main(string[] args) {
ArrayList arrList = new ArrayList();

// ArrayList füllen

Person pers1 = new Person { Name = "Meier", City = "Berlin" };
arrList.Add(pers1);
Person pers2 = new Person { Name = "Arnhold", City = "Köln" };
arrList.Add(pers2);
Person pers3 = new Person { Name = "Graubär", City = "Aachen" };
arrList.Add(pers3);

// nach Cities sortieren

arrList.Sort(new CityComparer());
Console.WriteLine("Liste nach Wohnorten sortiert");
ShowSortedList(arrList);

// nach Namen sortieren

arrList.Sort(new NameComparer());
Console.WriteLine("Liste nach Namen sortiert");
ShowSortedList(arrList);
}

static void ShowSortedList(IList liste) {
foreach(Person temp in liste) {
Console.Write("Name = {0,-12}", temp.Name);
Console.WriteLine("Wohnort = {0}", temp.City);
}
Console.WriteLine();
}
}

Listing 8.10 Das Beispielprogramm »IComparerSample«

Abbildung

Abbildung 8.3 Ausgabe des Beispiels »IComparerSample«


Galileo Computing - Zum Seitenanfang

8.3.4 Sortieren von Arrays mit »ArrayList.Adapter«Zur vorigen Überschrift

Ein herkömmliches Array bietet von Hause aus keine Möglichkeit, die in ihm enthaltenen Elemente zu sortieren. Es gibt dennoch einen Weg, der über die klassische Methode Adapter der Klasse ArrayList führt.

public static ArrayList Adapter(IList list);

Der Methode wird ein IList-Objekt übergeben. Der »Zufall« will es, dass ein klassisches Array diese Schnittstelle implementiert. Adapter legt einen Wrapper (darunter ist eine Klasse zu verstehen, die gewissermaßen um eine andere herumgelegt wird) um das IList-Objekt. Der Rückgabewert ist die Referenz auf ein neues ArrayList-Objekt, auf dessen Methoden, unter anderem auch Sort, sich das IList-Objekt manipulieren lässt.

Wie Sie die Methode Adapter einsetzen können, möchte ich Ihnen an einem Beispiel zeigen. Dabei dient wieder die Klasse Person aus dem Beispiel IComparerSample als Grundlage. Zudem soll auch wieder die Möglichkeit eröffnet werden, entweder nach Name oder City zu sortieren. Dazu können die Vergleichsklassen des Beispiels IComparerSample des letzten Abschnitts wiederverwendet werden.

// Beispiel: ..\Kapitel 8\ArrayListAdapterSample

class Program {
static void Main(string[] args){
Person[] pers = new Person[3];
pers[0] = new Person { Name = "Peter", City = "Celle" };
pers[1] = new Person { Name = "Alfred", City = "München" };
pers[2] = new Person { Name = "Hugo", City = "Aachen" };
ArrayList liste = ArrayList.Adapter(pers);

// Sortierung nach Namen

liste.Sort(new NameComparer());
Console.WriteLine("Sortiert nach den Namen:");
for (int index = 0; index < 3; index ++)
if( liste[index] != null)
Console.WriteLine(((Person)liste[index]).Name);

// Sortierung nach dem City

Console.WriteLine("\nSortiert nach dem Wohnort:");
liste.Sort(new CityComparer());
for (int index = 0; index < 3; index ++)
if( liste[index] != null)
Console.WriteLine(((Person)liste[index]).City);
Console.ReadLine();
}
}

Listing 8.11 Beispielprogramm mit der Methode »ArrayList.Adapter«

Bei der Ausgabe der sortierten Listenelemente müssen wir ein wenig vorsichtiger sein. Denn im Gegensatz zur ArrayList, die uns garantiert, dass sich hinter jedem Index ein gültiges Objekt verbirgt, kann der Index in einem klassischen Array null sein. Der Versuch einer Ausgabe oder ganz allgemein des Zugriffs auf ein null-Element würde mit einer Ausnahme quittiert. Daher ist unbedingt darauf zu achten, vor der Ausgabe mit

if (liste[index] != null)

auf den Inhalt null zu prüfen.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.

>> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2012

Visual C# 2012
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo





Copyright © Rheinwerk Verlag GmbH 2013
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de