Clase genérica List (System.Collections.Generic)

Cambiar vista

Contraer todo

Filtro de lenguage

Esta página es específica de

Microsoft Visual Studio 2005/.NET Framework 2.0

Hay además otras versiones disponibles para:

Biblioteca de clases de .NET Framework

Clase genérica List

Nota: esta clase es nueva en la versión 2.0 de .NET Framework.

Representa una lista de objetos con establecimiento inflexible de tipos a la que se puede obtener acceso por índice. Proporciona métodos para buscar, ordenar y manipular listas.

Espacio de nombres: System.Collections.Generic
Ensamblado: mscorlib (en mscorlib.dll)

Sintaxis

Visual Basic (Declaración)

<SerializableAttribute> _
Public Class List(Of T)
    Implements IList(Of T), ICollection(Of T), _
    IEnumerable(Of T), IList, ICollection, _
    IEnumerable

Visual Basic (Uso)

Dim instance As List(Of T)

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

C++

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

J# admite el uso de métodos y tipos genéricos, pero no admite la declaración de métodos y tipos nuevos.

JScript

JScript no admite el uso de métodos y tipos genéricos.

Parámetros de tipo

: T
Tipo de elementos en la lista.

Comentarios

La clase List es el equivalente genérico de la clase ArrayList. Implementa la interfaz genérica IList mediante una matriz cuyo tamaño aumenta dinámicamente según se requiera.

La clase List utiliza un comparador de igualdad y un comparador de orden.

Los métodos como Contains, IndexOf, LastIndexOf y Remove utilizan un comparador de igualdad para los elementos de lista. El comparador de igualdad predeterminado para el tipo T se determina de la siguiente manera. Si el tipo T implementa la interfaz genérica IEquatable, el comparador de igualdad será el método Equals de dicha interfaz; en caso contrario, el comparador de igualdad será Object.Equals(Object).
Los métodos como BinarySearch y Sort utilizan un comparador de orden para los elementos de lista. El comparador predeterminado para el tipo T se determina de la siguiente manera. Si el tipo T implementa la interfaz genérica IComparable, el comparador predeterminado será el método CompareTo de dicha interfaz; en caso contrario, si el tipo T implementa la interfaz no genérica IComparable, el comparador predeterminado será el método CompareTo de dicha interfaz. Si el tipo T no implementa ninguna de estas interfaces, no existirá un comparador predeterminado, por lo que habrá de proporcionarse explícitamente un comparador o un delegado de comparación.

No se garantiza que el objeto List esté ordenado. Debe ordenar List antes de realizar operaciones (como BinarySearch) que requieran que dicho objeto List esté ordenado.

Se puede obtener acceso a los elementos de esta colección utilizando un índice entero. Los índices de esta colección están basados en cero.

List acepta referencia de objeto null (Nothing en Visual Basic) como valor válido para los tipos de referencia y admite elementos duplicados.

Consideraciones de rendimiento

Cuando vaya a decidir si debe utilizar la clase List o la clase ArrayList, que tienen una funcionalidad similar, recuerde que, en la mayoría de los casos, el rendimiento de List es mejor y que tiene seguridad de tipos. Si para el tipo T de la clase List se utiliza un tipo de referencia, el comportamiento de ambas clases es idéntico. Sin embargo, si se utiliza un tipo de valor para el tipo T, habrá que tener en cuenta los problemas relacionados con la implementación y la conversión boxing.

Si se utiliza un tipo de valor para el tipo T, el compilador genera específicamente una implementación de la clase List para ese tipo de valor. Esto significa que no será necesario utilizar la conversión boxing para un elemento de lista de un objeto List antes de poder utilizar dicho elemento, por lo que, después de crear unos 500 elementos de lista, el ahorro de memoria por no aplicar la conversión boxing a los elementos de lista será mayor que la memoria utilizada para generar la implementación de la clase.

Asegúrese de que el tipo de valor que se utiliza para el tipo T implementa la interfaz genérica IEquatable. Si no, los métodos como Contains deben llamar al método Object.Equals(Object), que aplica la conversión boxing al elemento de lista afectado. Si el tipo de valor implementa la interfaz IComparable y el usuario es el propietario del código fuente, implemente también la interfaz genérica IComparable para evitar que los métodos BinarySearch y Sort apliquen la conversión boxing a los elementos de lista. Si el código fuente no es suyo, pase un objeto IComparer a los métodos BinarySearch y Sort

Supone una ventaja poder utilizar la implementación específica de tipo de la clase List en lugar de usar la clase ArrayList o escribir uno mismo una colección de contenedores con establecimiento inflexible de tipos El motivo es que la propia implementación debe hacer lo que .NET Framework ya realiza por el usuario y que Common Language Runtime es capaz de compartir los metadatos y el código del Lenguaje intermedio de Microsoft, algo que la propia implementación no puede hacer.

Ejemplo

En el ejemplo de código siguiente se muestran varias propiedades y métodos de la clase genérica List. Se utiliza el constructor predeterminado para crear una lista de cadenas con una capacidad de 0. Se muestra la propiedad Capacity y, a continuación, se utiliza el método Add para agregar varios elementos. Se confecciona la lista de elementos y se vuelve a mostrar nuevamente la propiedad Capacity, junto con la propiedad Count, para mostrar que la capacidad ha aumentado según era necesario.

Se utiliza el método Contains para comprobar la presencia de un elemento en la lista, también se utiliza el método Insert para insertar un nuevo elemento en mitad de la lista y se vuelve a mostrar el contenido de la lista.

Se utiliza la propiedad Item predeterminada (el indizador en C#) para recuperar un elemento, se usa el método Remove para quitar la primera instancia del elemento duplicado agregado anteriormente y se muestra el contenido nuevamente. El método Remove siempre quita la primera instancia que encuentra.

Se utiliza el método TrimExcess para reducir la capacidad de modo que coincida con el contador y se muestran las propiedades Capacity y Count. Si la capacidad no utilizada hubiera sido menor al 10 por ciento de la capacidad total, el tamaño de la lista no se habría cambiado.

Por último, se utiliza el método Clear para quitar todos los elementos de la lista y se muestran las propiedades Capacity y Count.

Visual Basic

Imports System
Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)

        Console.WriteLine(vbLf & "Capacity: {0}", dinosaurs.Capacity)

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

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)

        Console.WriteLine(vbLf & "Contains(""Deinonychus""): {0}", _
            dinosaurs.Contains("Deinonychus"))

        Console.WriteLine(vbLf & "Insert(2, ""Compsognathus"")")
        dinosaurs.Insert(2, "Compsognathus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "dinosaurs(3): {0}", dinosaurs(3))

        Console.WriteLine(vbLf & "Remove(""Compsognathus"")")
        dinosaurs.Remove("Compsognathus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        dinosaurs.TrimExcess()
        Console.WriteLine(vbLf & "TrimExcess()")
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)

        dinosaurs.Clear()
        Console.WriteLine(vbLf & "Clear()")
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)
    End Sub
End Class

' 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

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

C++

using namespace System;
using namespace System::Collections::Generic;

void main()
{
    List<String^>^ dinosaurs = gcnew 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();
    for each(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();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

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

    Console::WriteLine("\nRemove(\"Compsognathus\")");
    dinosaurs->Remove("Compsognathus");

    Console::WriteLine();
    for each(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
 */

Jerarquía de herencia

System.Object
System.Collections.Generic.List

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

List puede admitir varios sistemas de lectura a la vez, siempre y cuando no se modifique la colección. La enumeración a través de una colección es un procedimiento sin seguridad intrínseca para la ejecución de subprocesos. En los casos excepcionales en los que una enumeración tiene que enfrentarse a uno o varios accesos de escritura, la única forma de garantizar la seguridad para la ejecución de subprocesos es bloquear la colección durante toda la enumeración. Para permitir que varios subprocesos obtengan acceso de lectura y escritura a la colección, debe implementar su propia sincronización.

Plataformas

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

Información de versión