Exportar (0) Imprimir
Expandir todo

SortedList<TKey, TValue> (Clase)

Actualización: noviembre 2007

Representa una colección de pares clave/valor que se ordenan conforme a la clave basándose en la implementación de IComparer<T> asociada.

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

[SerializableAttribute]
[ComVisibleAttribute(false)]
public class SortedList<TKey, TValue> : IDictionary<TKey, TValue>, 
	ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IDictionary, ICollection, IEnumerable

J# admite el uso de APIs genéricas pero no admite la declaración de nuevas API.
JScript no admite el uso de métodos ni tipos genéricos.

Parámetros de tipo

TKey

Tipo de claves de la colección.

TValue

Tipo de valores de la colección.

La clase genérica SortedList<TKey, TValue> es un árbol de búsqueda binaria que recupera mediante O(logn), donde n es el número de elementos del diccionario. En este aspecto, es similar a la clase genérica SortedDictionary<TKey, TValue>. Las dos clases tienen modelos de objetos similares y ambas recuperan mediante O(log n). En lo que se diferencian las dos clases es en el uso de memoria y en la velocidad de inserción y eliminación:

Otra diferencia entre las clases SortedDictionary<TKey, TValue> y SortedList<TKey, TValue> es que SortedList<TKey, TValue> admite la recuperación indizada eficaz de claves y valores mediante las colecciones que devuelven las propiedades Keys y Values. Cuando se obtiene acceso a las propiedades, no es necesario volver a generar las listas puesto que éstas únicamente son contenedores para las matrices internas de claves y valores. En el código siguiente se muestra el uso de la propiedad Values para la recuperación indizada de valores de una lista ordenada de cadenas:

string v = mySortedList.Values[3];

SortedList<TKey, TValue> se implementa como una matriz de pares clave/valor, ordenada conforme a la clave. Cada elemento se puede recuperar como un objeto KeyValuePair<TKey, TValue>.

Los objetos de claves deben permanecer inmutables mientras se utilicen como claves en SortedList<TKey, TValue>. Todas las claves de una colección SortedList<TKey, TValue> deben ser únicas. Una clave no puede ser null, pero un valor sí puede serlo si el tipo de los valores de la lista, TValue, es un tipo de referencia.

SortedList<TKey, TValue> requiere la implementación de un comparador para ordenar y realizar comparaciones. El comparador predeterminado Comparer<T>.Default comprueba si el tipo de clave TKey implementa System.IComparable<T> y utiliza esa implementación, si está disponible. En caso contrario, Comparer<T>.Default comprueba si el tipo de clave TKey implementa System.IComparable. Si el tipo de clave TKey no implementa ninguna de las interfaces, se puede especificar una implementación de System.Collections.Generic.IComparer<T> en una sobrecarga de constructor que acepte un parámetro comparer.

La capacidad de una colección SortedList<TKey, TValue> es el número de elementos que dicha SortedList<TKey, TValue> puede contener. Cuando se agregan elementos a una colección SortedList<TKey, TValue>, la capacidad aumenta automáticamente según sea necesario mediante la reasignación de la matriz interna. La capacidad se puede disminuir si se llama al método TrimExcess o si se establece explícitamente la propiedad Capacity. Al disminuir la capacidad se reasigna memoria y se copian todos los elementos de la colección SortedList<TKey, TValue>.

La instrucción foreach del lenguaje C# (for each en C++, For Each en Visual Basic) requiere el tipo de los elementos de la colección. Como los elementos de SortedList<TKey, TValue> son pares clave/valor, el tipo del elemento no se corresponde con el tipo de la clave, ni con el del valor. En su lugar, el tipo del elemento es KeyValuePair<TKey, TValue>. Por ejemplo:

foreach (KeyValuePair<int, string> kvp in mySortedList) {...}

La instrucción foreach es un contenedor del enumerador, que sólo permite la lectura pero no la escritura en la colección.

En el ejemplo de código siguiente se crea una colección SortedList<TKey, TValue> vacía de cadenas con claves de cadena y se utiliza el método Add para agregar algunos elementos. En él, se muestra que el método Add produce una excepción ArgumentException cuando se intenta agregar una clave duplicada.

Asimismo, se utiliza la propiedad Item (el indizador en C#) para recuperar los valores, mostrando que se produce una excepción KeyNotFoundException cuando no está presente una clave solicitada, y que se puede reemplazar el valor asociado a una clave.

En el ejemplo se muestra cómo utilizar el método TryGetValue como una forma más eficaz de recuperar valores si un programa debe probar con frecuencia valores de clave que no están en la lista ordenada, y se muestra cómo utilizar el método ContainsKey para comprobar si una clave existe antes de llamar al método Add.

Además, en el ejemplo se muestra cómo enumerar las claves y los valores de la lista ordenada, y cómo enumerar sólo las claves y los valores utilizando la propiedad Keys y la propiedad Values.

Por último, en el ejemplo se muestra el método Remove.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create a new sorted list of strings, with string
        // keys.
        SortedList<string, string> openWith = 
            new SortedList<string, string>();

        // Add some elements to the list. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the list.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the list.
        try
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", 
                openWith["tif"]);
        }
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the list, TryGetValue can be a more efficient 
        // way to retrieve values.
        string value = "";
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", 
                openWith["ht"]);
        }

        // When you use foreach to enumerate list elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( KeyValuePair<string, string> kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", 
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        IList<string> ilistValues = openWith.Values;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SorteList values.
        Console.WriteLine();
        foreach( string s in ilistValues )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // The Values property is an efficient way to retrieve
        // values by index.
        Console.WriteLine("\nIndexed retrieval using the Values " +
            "property: Values[2] = {0}", openWith.Values[2]);

        // To get the keys alone, use the Keys property.
        IList<string> ilistKeys = openWith.Keys;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SortedList keys.
        Console.WriteLine();
        foreach( string s in ilistKeys )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // The Keys property is an efficient way to retrieve
        // keys by index.
        Console.WriteLine("\nIndexed retrieval using the Keys " +
            "property: Keys[2] = {0}", openWith.Keys[2]);

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe
Key = rtf, Value = winword.exe
Key = txt, Value = notepad.exe

Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = hypertrm.exe
Value = winword.exe
Value = notepad.exe

Indexed retrieval using the Values property: Values[2] = winword.exe

Key = bmp
Key = dib
Key = doc
Key = ht
Key = rtf
Key = txt

Indexed retrieval using the Keys property: Keys[2] = doc

Remove("doc")
Key "doc" is not found.
 */


System.Object
  System.Collections.Generic.SortedList<TKey, TValue>

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.

SortedList<TKey, TValue> 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. Para garantizar la seguridad para la ejecución de subprocesos durante la enumeración, puede 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 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 para Smartphone, Windows Mobile para Pocket PC, Xbox 360

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0

.NET Compact Framework

Compatible con: 3.5, 2.0

XNA Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft