List(T)-Klasse
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern

List<T>-Klasse

Aktualisiert: November 2007

Stellt eine stark typisierte Liste von Objekten dar, auf die über einen Index zugegriffen werden kann. Stellt Methoden zum Durchsuchen, Sortieren und Bearbeiten von Listen bereit.

Namespace:  System.Collections.Generic
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
public class List<T> : IList<T>, ICollection<T>, 
	IEnumerable<T>, IList, ICollection, IEnumerable

J# unterstützt die Verwendung von generischen APIs, aber nicht die Deklaration von neuen generischen APIs.
JScript unterstützt keine generischen Typen oder Methoden.

Typparameter

T

Der Typ der Elemente in der Liste.

Die List<T>-Klasse stellt die generische Entsprechung der ArrayList-Klasse dar. Sie implementiert die generische IList<T>-Schnittstelle unter Verwendung eines Arrays, das nach Bedarf dynamisch vergrößert wird.

Die List<T>-Klasse verwendet sowohl einen Gleichheitsvergleich als auch einen Reihenfolgevergleich.

  • Beispielsweise verwenden die Methoden Contains, IndexOf, LastIndexOf und Remove einen Gleichheitsvergleich für die Listenelemente. Der Standardgleichheitsvergleich für Typ T wird wie folgt bestimmt. Wenn Typ T die generische IEquatable<T>-Schnittstelle implementiert, entspricht der Gleichheitsvergleich der Equals(T)-Methode dieser Schnittstelle. Andernfalls ist der Standardgleichheitsvergleich Object.Equals(Object).

  • Methoden wie BinarySearch und Sort verwenden für die Listenelemente einen Reihenfolgevergleich. Der Standardvergleich für Typ T wird wie folgt bestimmt. Wenn Typ T die generische IComparable<T>-Schnittstelle implementiert, entspricht der Standardvergleich der CompareTo(T)-Methode dieser Schnittstelle. Wenn andernfalls Typ T die nicht generische IComparable-Schnittstelle implementiert, entspricht der Standardvergleich der CompareTo(Object)-Methode dieser Schnittstelle. Wenn Typ T keine der Schnittstellen implementiert, ist kein Standardvergleich vorhanden, und ein Vergleich oder Vergleichsdelegat muss explizit angegeben werden.

Es wird nicht sichergestellt, dass die List<T> sortiert ist. Sie müssen List<T> sortieren, bevor Sie Operationen wie BinarySearch durchführen, die eine sortierte List<T> voraussetzen.

Auf Elemente in dieser Auflistung kann mithilfe eines ganzzahligen Index zugegriffen werden. Diese Auflistung verwendet nullbasierte Indizes.

List<T> akzeptiert null als gültigen Wert für Referenztypen und lässt doppelte Elemente zu.

Überlegungen zur Leistung

Beim Entscheiden über die Verwendung der List<T>-Klasse oder der ArrayList-Klasse, die beide über ähnliche Funktionen verfügen, müssen Sie bedenken, dass die List<T>-Klasse in den meisten Fällen eine bessere Leistung bietet und typsicher ist. Wenn für den Typ T der List<T>-Klasse ein Referenztyp verwendet wird, stimmt das Verhalten der beiden Klassen überein. Wenn für den Typ T hingegen ein Werttyp verwendet wird, müssen Sie Aspekte wie die Implementierung und Boxing berücksichtigen.

Wenn für den Typ T ein Werttyp verwendet wird, generiert der Compiler eine Implementierung der List<T>-Klasse speziell für diesen Werttyp. Das bedeutet, dass ein Listenelement eines List<T>-Objekts nicht geschachtelt werden muss, bevor das Element verwendet werden kann, und nachdem etwa 500 Listenelemente erstellt wurden, ist der Speicher mit Listenelementen ohne Boxing größer als der zum Generieren der Klassenimplementierung verwendete Speicher.

Stellen Sie sicher, dass der für Typ T verwendete Werttyp die generische IEquatable<T>-Schnittstelle implementiert. Andernfalls müssen Methoden wie Contains die Object.Equals(Object)-Methode aufrufen, die das betreffende Listenelement schachtelt. Wenn der Werttyp die IComparable-Schnittstelle implementiert und Sie den Quellcode besitzen, implementieren Sie zusätzlich die generische IComparable<T>-Schnittstelle, um zu verhindern, dass die BinarySearch-Methode und die Sort-Methode Listenelemente schachteln. Wenn Sie den Quellcode nicht besitzen, übergeben Sie ein IComparer<T>-Objekt an die BinarySearch-Methode und an die Sort-Methode.

Es ist für Sie von Vorteil, die typspezifische Implementierung der List<T>-Klasse zu verwenden, anstatt die ArrayList-Klasse zu verwenden oder selbst eine stark typisierte Wrapperauflistung zu schreiben. Der Grund dafür besteht darin, dass Ihre Implementierung die Schritte ausführen muss, die .NET Framework bereits für Sie ausführt, und dass die Common Language Runtime im Gegensatz zu Ihrer Implementierung den Code und der Microsoft Intermediate Language sowie Metadaten freigeben kann.

Im folgenden Codebeispiel werden verschiedene Eigenschaften und Methoden der generischen List<T>-Klasse veranschaulicht. Der Standardkonstruktor wird verwendet, um eine Liste von Zeichenfolgen mit der Standardkapazität zu erstellen. Die Capacity-Eigenschaft wird angezeigt, und anschließend wird die Add-Methode verwendet, um mehrere Elemente hinzuzufügen. Die Elemente werden aufgelistet, und die Capacity-Eigenschaft wird erneut angezeigt – zusammen mit der Count-Eigenschaft, damit deutlich wird, dass die Kapazität nach Bedarf erhöht wurde.

Mit der Contains-Methode wird das Vorhandensein eines Elements in der Liste geprüft, mit der Insert-Methode wird ein neues Element in die Mitte der Liste eingefügt, und der Inhalt der Liste wird erneut angezeigt.

Die Item-Standardeigenschaft (der Indexer in C#) wird zum Abrufen eines Elements verwendet, mit der Remove-Methode wird die erste Instanz des zuvor hinzugefügten doppelten Elements entfernt, und der Inhalt wird erneut angezeigt. Die Remove-Methode entfernt stets die erste gefundene Instanz.

Mit der TrimExcess-Methode wird die Kapazität so verringert, dass sie der Anzahl entspricht, und die Capacity-Eigenschaft sowie die Count-Eigenschaft werden angezeigt. Wenn die nicht verwendete Kapazität weniger als 10 Prozent der Gesamtkapazität betragen hätte, wäre die Größe der Liste nicht geändert worden.

Abschließend werden mithilfe der Clear-Methode alle Elemente aus der Liste entfernt. Die Capacity-Eigenschaft und die Count-Eigenschaft werden angezeigt.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        Console.WriteLine("\nContains(\"Deinonychus\"): {0}",
            dinosaurs.Contains("Deinonychus"));

        Console.WriteLine("\nInsert(2, \"Compsognathus\")");
        dinosaurs.Insert(2, "Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

        Console.WriteLine("\nRemove(\"Compsognathus\")");
        dinosaurs.Remove("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        dinosaurs.TrimExcess();
        Console.WriteLine("\nTrimExcess()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        dinosaurs.Clear();
        Console.WriteLine("\nClear()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);
    }
}

/* This code example produces the following output:

Capacity: 0

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

Contains("Deinonychus"): True

Insert(2, "Compsognathus")

Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus

dinosaurs[3]: Mamenchisaurus

Remove("Compsognathus")

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

TrimExcess()
Capacity: 5
Count: 5

Clear()
Capacity: 5
Count: 0
 */


Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

List<T> stellt eine gleichzeitige Unterstützung für mehrere Reader bereit, sofern die Auflistung nicht verändert wird. Die Enumeration einer Auflistung ist systemintern keine threadsichere Prozedur. Für den seltenen Fall, dass Konflikte zwischen einer Enumeration und einem oder mehreren Schreibzugriffen auftreten, besteht die einzige Möglichkeit der Gewährleistung der Threadsicherheit im Sperren der Auflistung während der gesamten Enumeration. Um den Lese- und Schreibzugriff auf diese Auflistung durch mehrere Threads zuzulassen, müssen Sie eine eigene Synchronisierung implementieren.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC, Xbox 360

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0

.NET Compact Framework

Unterstützt in: 3.5, 2.0

XNA Framework

Unterstützt in: 2.0, 1.0

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2016 Microsoft