Esta documentación está archivada y no tiene mantenimiento.

Clase genérica LinkedList

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

Representa una lista doblemente vinculada.

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

[SerializableAttribute] 
[ComVisibleAttribute(false)] 
public class LinkedList<T> : ICollection<T>, IEnumerable<T>, 
	ICollection, IEnumerable, ISerializable, IDeserializationCallback
J# admite el uso de métodos y tipos genéricos, pero no admite la declaración de métodos y tipos nuevos.
JScript no admite el uso de métodos y tipos genéricos.

Parámetros de tipo

T

Especifica el tipo de elemento de la lista vinculada.

LinkedList es una lista vinculada de uso general. Admite los enumeradores e implementa la interfaz ICollection, de forma coherente con las demás clases de colecciones de .NET Framework.

LinkedList es una lista verdaderamente vinculada con nodos independientes de tipo LinkedListNode, por lo que la inserción y la eliminación son operaciones O (1). Las listas que contienen tipos de referencia tienen un rendimiento mejor si un nodo y su valor se crean al mismo tiempo. Como se exponen los nodos subyacentes, es posible quitar nodos y volverlos a insertarlos en la misma lista o en otra, como una operación O(1) sin asignaciones en el montón GC. La lista también mantiene un contador interno de modo que la obtención de la propiedad Count es una operación O(1); el contador es coherente siempre y cuando la lista se utilice a partir de un único subproceso.

La clase LinkedList no admite el encadenamiento, las divisiones, los ciclos u otras características que puedan hacer que la lista pierda su coherencia. El diseño favorece el mantenimiento de la integridad de la lista, la cual conserva la coherencia en las operaciones con un solo subproceso. El único escenario multiproceso que admite LinkedList son las operaciones de lectura multiproceso. En otros escenarios multiproceso, debe proporcionar su propia sincronización.

NotaNota

Siempre es posible crear listas vinculadas que rindan mejor en circunstancias concretas o que hagan concesiones a la seguridad en la programación en favor de las características adicionales.

Cada nodo de la colección LinkedList es del tipo LinkedListNode. Dado que la colección LinkedList está doblemente vinculada, cada nodo señala hacia delante al nodo Next y hacia atrás al nodo Previous. Los nodos están vinculados a la lista, de modo que las operaciones no válidas en la lista (por ejemplo, el intento de borrar un nodo que realmente se encuentre en otra lista) no provocan ningún estado de falta de coherencia.

LinkedList acepta referencia de objeto null (Nothing en Visual Basic) como Value válido para los tipos de referencia y admite valores duplicados.

Si la colección LinkedList está vacía, las propiedades First y Last contienen referencia de objeto null (Nothing en Visual Basic).

En el ejemplo de código siguiente se muestran muchas características de la clase LinkedList. En este ejemplo se crea una matriz de cadenas y, a continuación, se crea y rellena una lista LinkedList de cadenas pasando la matriz de cadenas al constructor LinkedList(IEnumerable genérico).

En el ejemplo de código se manipula la lista vinculada resultante mediante las propiedades y métodos de la clase LinkedList, mostrando los resultados que se producen entre las operaciones.

using System;
using System.Text;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        string[] words = 
            {"the", "fox", "jumped", "over", "the", "dog"};
        LinkedList<string> sentence = new LinkedList<string>(words);
        Display(sentence);

        Console.WriteLine("sentence.Contains(\"jumped\") = {0}", 
            sentence.Contains("jumped"));

        // Add the word "today" to the beginning of the linked list.
        // Remove the new node, and add it to the end of the list.
        sentence.AddFirst("today");
        Display(sentence);

        LinkedListNode<string> mark1 = sentence.First;
        sentence.RemoveFirst();
        sentence.AddLast(mark1);
        Display(sentence);

        sentence.RemoveLast();
        sentence.AddLast("yesterday");
        Display(sentence);

        mark1 = sentence.Last;
        sentence.RemoveLast();
        sentence.AddFirst(mark1);
        Display(sentence);

        sentence.RemoveFirst();

        LinkedListNode<string> current = sentence.FindLast("the");
        DisplayNode(current);

        sentence.AddAfter(current, "old");
        sentence.AddAfter(current, "lazy");
        DisplayNode(current);

        current = sentence.Find("fox");
        DisplayNode(current);

        sentence.AddBefore(current, "quick");
        sentence.AddBefore(current, "brown");
        DisplayNode(current);

        // Keep a reference to the current node, "fox", and to the
        // previous node in the list. Use the Find method to locate
        // the node containing the value "dog". Show the position.
        mark1 = current;
        LinkedListNode<string> mark2 = current.Previous;
        current = sentence.Find("dog");
        DisplayNode(current);

        // The AddBefore method throws an InvalidOperationException
        // if you try to add a node that already belongs to a list.
        try
        {
            sentence.AddBefore(current, mark1);
        }
        catch(InvalidOperationException ex)
        {
            Console.WriteLine("Exception message: {0}", ex.Message);
        }

        // Remove the node referred to by mark1, and add it before 
        // the node referred to by current. Show the sentence, 
        // highlighting the position of the node referred to by
        // current.
        sentence.Remove(mark1);
        sentence.AddBefore(current, mark1);
        DisplayNode(current);

        // Remove the node referred to by current. If you try to show
        // its position now, the DisplayNode method prints a message.
        // Add the node after the node referred to by mark2, and 
        // display the sentence, highlighting current.
        sentence.Remove(current);
        DisplayNode(current);
        sentence.AddAfter(mark2, current);
        DisplayNode(current);

        // The Remove method finds and removes the first node that 
        // that has the specified value.
        sentence.Remove("old");
        Display(sentence);

        // When the linked list is cast to ICollection(Of String),
        // the Add method adds a node to the end of the list. 
        sentence.RemoveLast();
        ICollection<string> icoll = sentence;
        icoll.Add("rhinoceros");
        Display(sentence);

        // Create an array with the same number of elements as the
        // linked list.
        Console.WriteLine("\nCopy the list to an array.");
        string[] sArray = new string[sentence.Count];
        sentence.CopyTo(sArray, 0);

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

        // Release all the nodes.
        sentence.Clear();

    }

    private static void Display(LinkedList<string> words)
    {
        foreach( string word in words )
        {
            Console.Write(word + " ");
        }
        Console.WriteLine();
    }
    
    private static void DisplayNode(LinkedListNode<string> node)
    {
        if (node.List==null)
        {
            Console.WriteLine("Node \"{0}\" is not in a list.", 
                node.Value);
            return;
        }

        StringBuilder result = new StringBuilder("(" + node.Value + ")");
        LinkedListNode<string> nodeP = node.Previous;

        while (nodeP != null)
        {
            result.Insert(0, nodeP.Value + " ");
            nodeP = nodeP.Previous;
        }

        node = node.Next;
        while (node != null)
        {
            result.Append(" " + node.Value);
            node = node.Next;
        }

        Console.WriteLine(result);
    }
}

//This code example produces the following output:
//
//the fox jumped over the dog
//sentence.Contains("jumped") = True
//today the fox jumped over the dog
//the fox jumped over the dog today
//the fox jumped over the dog yesterday
//yesterday the fox jumped over the dog
//the fox jumped over (the) dog
//the fox jumped over (the) lazy old dog
//the (fox) jumped over the lazy old dog
//the quick brown (fox) jumped over the lazy old dog
//the quick brown fox jumped over the lazy old (dog)
//Exception message: The LinkedList node belongs a LinkedList.
//the quick brown jumped over the lazy old fox (dog)
//Node "dog" is not in a list.
//the quick brown (dog) jumped over the lazy old fox
//the quick brown dog jumped over the lazy fox
//the quick brown dog jumped over the lazy rhinoceros
//
//Copy the list to an array.
//the
//quick
//brown
//dog
//jumped
//over
//the
//lazy
//rhinoceros

System.Object
  System.Collections.Generic.LinkedList

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.

LinkedList puede admitir varios sistemas de lectura a la vez, siempre y cuando no se modifique la colección. Aun así, por su naturaleza, la enumeración mediante una colección no es un procedimiento seguro para la ejecución de subprocesos. En el caso excepcional de que haya un conflicto entre una enumeración y los accesos de escritura, se debe 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.

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.

.NET Framework

Compatible con: 2.0

.NET Compact Framework

Compatible con: 2.0
Mostrar: