List<T> Constructores

Definición

Espacio de nombres:

System.Collections.Generic

Ensamblado:

System.Collections.dll

Inicializa una nueva instancia de la clase List<T>.

Sobrecargas

List<T>()	Inicializa una nueva instancia de la clase List<T> que está vacía y tiene la capacidad inicial predeterminada.
List<T>(IEnumerable<T>)	Inicializa una nueva instancia de la clase List<T> que contiene elementos copiados de la colección especificada y tiene una capacidad suficiente para aceptar el número de elementos copiados.
List<T>(Int32)	Inicializa una nueva instancia de la clase List<T> que está vacía y tiene la capacidad inicial especificada.

List<T>()

Source:

List.cs

Inicializa una nueva instancia de la clase List<T> que está vacía y tiene la capacidad inicial predeterminada.

C#

public List ();

Ejemplos

En el ejemplo siguiente se muestra el constructor sin parámetros de la List<T> clase genérica. El constructor sin parámetros crea una lista con la capacidad predeterminada, como se muestra mostrando la Capacity propiedad .

En el ejemplo se agregan, insertan y quitan elementos, en los que se muestra cómo cambia la capacidad a medida que se usan estos métodos.

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
 */

Comentarios

La capacidad de es List<T> el número de elementos que List<T> puede contener. A medida que se agregan elementos a , List<T>la capacidad aumenta automáticamente según sea necesario mediante la reasignación de la matriz interna.

Si se puede calcular el tamaño de la colección, el uso del List<T>(Int32) constructor y la especificación de la capacidad inicial elimina la necesidad de realizar una serie de operaciones de cambio de tamaño al agregar elementos a List<T>.

La capacidad se puede reducir llamando al TrimExcess método o estableciendo la Capacity propiedad explícitamente. Al disminuir la capacidad, se reasigna la memoria y se copian todos los elementos de List<T>.

Este constructor es una operación O(1).

List<T>(IEnumerable<T>)

Source:

List.cs

Inicializa una nueva instancia de la clase List<T> que contiene elementos copiados de la colección especificada y tiene una capacidad suficiente para aceptar el número de elementos copiados.

C#

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

Parámetros

collection

IEnumerable<T>

Colección cuyos elementos se copian en la nueva lista.

Excepciones

ArgumentNullException

collection es null.

Ejemplos

En el ejemplo siguiente se muestra el List<T> constructor y varios métodos de la List<T> clase que actúan en intervalos. Se crea una matriz de cadenas y se pasa al constructor rellenando la lista con los elementos de la matriz. A Capacity continuación, se muestra la propiedad para mostrar que la capacidad inicial es exactamente lo que se necesita para contener los elementos de entrada.

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
 */

Comentarios

Los elementos se copian en en List<T> el mismo orden en que los lee el enumerador de la colección.

Este constructor es una operación O(n), donde n es el número de elementos de collection.

Consulte también

• IEnumerable<T>
• Capacity

List<T>(Int32)

Source:

List.cs

Inicializa una nueva instancia de la clase List<T> que está vacía y tiene la capacidad inicial especificada.

C#

public List (int capacity);

Parámetros

capacity

Int32

Número de elementos que puede almacenar inicialmente la lista nueva.

Excepciones

ArgumentOutOfRangeException

capacity es menor que 0.

Ejemplos

En el ejemplo siguiente se muestra el List<T>(Int32) constructor . Se List<T> crea una de cadenas con una capacidad de 4, porque se sabe que el tamaño final de la lista es exactamente 4. La lista se rellena con cuatro cadenas y se crea una copia de solo lectura mediante el AsReadOnly método .

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
 */

Comentarios

La capacidad de es List<T> el número de elementos que List<T> puede contener. A medida que se agregan elementos a , List<T>la capacidad aumenta automáticamente según sea necesario mediante la reasignación de la matriz interna.

Si se puede estimar el tamaño de la colección, especificar la capacidad inicial elimina la necesidad de realizar una serie de operaciones de cambio de tamaño al agregar elementos a List<T>.

La capacidad se puede reducir llamando al TrimExcess método o estableciendo la Capacity propiedad explícitamente. Al disminuir la capacidad, se reasigna la memoria y se copian todos los elementos de List<T>.

Este constructor es una operación O(1).

Consulte también

• Capacity