List<T> Konstruktoren

Definition

Namespace:

System.Collections.Generic

Assembly:

System.Collections.dll

Initialisiert eine neue Instanz der List<T>-Klasse.

Überlädt

List<T>()	Initialisiert eine neue, leere Instanz der List<T>-Klasse, die die Standardanfangskapazität aufweist.
List<T>(IEnumerable<T>)	Initialisiert eine neue Instanz der List<T>-Klasse, die aus der angegebenen Auflistung kopierte Elemente enthält und eine ausreichende Kapazität für die Anzahl der kopierten Elemente aufweist.
List<T>(Int32)	Initialisiert eine neue, leere Instanz der List<T>-Klasse, die die angegebene Anfangskapazität aufweist.

List<T>()

Quelle:

List.cs

Initialisiert eine neue, leere Instanz der List<T>-Klasse, die die Standardanfangskapazität aufweist.

C#

public List ();

Beispiele

Im folgenden Beispiel wird der parameterlose Konstruktor der List<T> generischen Klasse veranschaulicht. Der parameterlose Konstruktor erstellt eine Liste mit der Standardkapazität, wie durch anzeigen der Capacity -Eigenschaft veranschaulicht.

Im Beispiel werden Elemente hinzugefügt, eingefügt und entfernt, und es wird veranschaulicht, wie sich die Kapazität ändert, wenn diese Methoden verwendet werden.

C#

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);
}

// Shows accessing the list using the Item property.
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
 */

Hinweise

Die Kapazität eines List<T> ist die Anzahl von Elementen, die in List<T> enthalten sein können. Wenn Elemente zu einer List<T>hinzugefügt werden, wird die Kapazität bei Bedarf automatisch erhöht, indem das interne Array neu zugeordnet wird.

Wenn die Größe der Auflistung geschätzt werden kann, entfällt durch Die Verwendung des List<T>(Int32) Konstruktors und die Angabe der anfänglichen Kapazität die Notwendigkeit, eine Reihe von Größenänderungsvorgängen durchzuführen, während Elemente zum hinzugefügt werden List<T>.

Die Kapazität kann durch Aufrufen der TrimExcess -Methode oder durch explizites Festlegen der Capacity -Eigenschaft verringert werden. Wenn Sie die Kapazität verringern, wird der Arbeitsspeicher neu zugeordnet und alle Elemente in kopiert List<T>.

Dieser Konstruktor ist ein O(1)-Vorgang.

List<T>(IEnumerable<T>)

Quelle:

List.cs

Initialisiert eine neue Instanz der List<T>-Klasse, die aus der angegebenen Auflistung kopierte Elemente enthält und eine ausreichende Kapazität für die Anzahl der kopierten Elemente aufweist.

C#

public List (System.Collections.Generic.IEnumerable<T> collection);

Parameter

collection

IEnumerable<T>

Die Auflistung, deren Elemente in die neue Liste kopiert werden.

Ausnahmen

ArgumentNullException

collection ist null.

Beispiele

Im folgenden Beispiel werden der List<T> Konstruktor und verschiedene Methoden der -Klasse veranschaulicht, die List<T> auf Bereiche reagieren. Ein Array von Zeichenfolgen wird erstellt und an den Konstruktor übergeben, wobei die Liste mit den Elementen des Arrays aufgefüllt wird. Die Capacity -Eigenschaft wird dann angezeigt, um anzuzeigen, dass die anfängliche Kapazität genau die ist, die für die Aufnahme der Eingabeelemente erforderlich ist.

C#

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        string[] input = { "Brachiosaurus",
                           "Amargasaurus",
                           "Mamenchisaurus" };

        List<string> dinosaurs = new List<string>(input);

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

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

        Console.WriteLine("\nAddRange(dinosaurs)");
        dinosaurs.AddRange(dinosaurs);

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

        Console.WriteLine("\nRemoveRange(2, 2)");
        dinosaurs.RemoveRange(2, 2);

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

        input = new string[] { "Tyrannosaurus",
                               "Deinonychus",
                               "Velociraptor"};

        Console.WriteLine("\nInsertRange(3, input)");
        dinosaurs.InsertRange(3, input);

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

        Console.WriteLine("\noutput = dinosaurs.GetRange(2, 3).ToArray()");
        string[] output = dinosaurs.GetRange(2, 3).ToArray();

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

/* This code example produces the following output:

Capacity: 3

Brachiosaurus
Amargasaurus
Mamenchisaurus

AddRange(dinosaurs)

Brachiosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Amargasaurus
Mamenchisaurus

RemoveRange(2, 2)

Brachiosaurus
Amargasaurus
Amargasaurus
Mamenchisaurus

InsertRange(3, input)

Brachiosaurus
Amargasaurus
Amargasaurus
Tyrannosaurus
Deinonychus
Velociraptor
Mamenchisaurus

output = dinosaurs.GetRange(2, 3).ToArray()

Amargasaurus
Tyrannosaurus
Deinonychus
 */

Hinweise

Die Elemente werden in der reihenfolge kopiert, List<T> in der sie vom Enumerator der Auflistung gelesen werden.

Dieser Konstruktor ist ein O(n)-Vorgang, wobei n die Anzahl der Elemente in collectionist.

Weitere Informationen

• IEnumerable<T>
• Capacity

List<T>(Int32)

Quelle:

List.cs

Initialisiert eine neue, leere Instanz der List<T>-Klasse, die die angegebene Anfangskapazität aufweist.

C#

public List (int capacity);

Parameter

capacity

Int32

Die Anzahl von Elementen, die anfänglich in der neuen Liste gespeichert werden können.

Ausnahmen

ArgumentOutOfRangeException

capacity ist kleiner als 0.

Beispiele

Im folgenden Beispiel wird der List<T>(Int32) Konstruktor veranschaulicht. Eine List<T> von Zeichenfolgen mit einer Kapazität von 4 wird erstellt, da die endgültige Größe der Liste bekanntlich genau 4 ist. Die Liste wird mit vier Zeichenfolgen aufgefüllt, und eine schreibgeschützte Kopie wird mithilfe der AsReadOnly -Methode erstellt.

C#

using System;
using System.Collections.Generic;

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

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

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

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

        Console.WriteLine("\nIList<string> roDinosaurs = dinosaurs.AsReadOnly()");
        IList<string> roDinosaurs = dinosaurs.AsReadOnly();

        Console.WriteLine("\nElements in the read-only IList:");
        foreach(string dinosaur in roDinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\ndinosaurs[2] = \"Coelophysis\"");
        dinosaurs[2] = "Coelophysis";

        Console.WriteLine("\nElements in the read-only IList:");
        foreach(string dinosaur in roDinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Capacity: 4

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

IList<string> roDinosaurs = dinosaurs.AsReadOnly()

Elements in the read-only IList:
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

dinosaurs[2] = "Coelophysis"

Elements in the read-only IList:
Tyrannosaurus
Amargasaurus
Coelophysis
Deinonychus
 */

Hinweise

Die Kapazität eines List<T> ist die Anzahl von Elementen, die in List<T> enthalten sein können. Wenn Elemente zu einer List<T>hinzugefügt werden, wird die Kapazität bei Bedarf automatisch erhöht, indem das interne Array neu zugeordnet wird.

Wenn die Größe der Sammlung geschätzt werden kann, entfällt die Angabe der anfänglichen Kapazität die Notwendigkeit, eine Reihe von Größenänderungsvorgängen durchzuführen, während Elemente zu hinzugefügt werden List<T>.

Die Kapazität kann durch Aufrufen der TrimExcess -Methode oder durch explizites Festlegen der Capacity -Eigenschaft verringert werden. Wenn Sie die Kapazität verringern, wird der Arbeitsspeicher neu zugeordnet und alle Elemente in kopiert List<T>.

Dieser Konstruktor ist ein O(1)-Vorgang.

Weitere Informationen

• Capacity