SortedList SortedList SortedList SortedList Class

Definición

Representa una colección de pares de clave y valor ordenados por claves a los que se puede tener acceso por clave y por índice.Represents a collection of key/value pairs that are sorted by the keys and are accessible by key and by index.

public ref class SortedList : ICloneable, System::Collections::IDictionary
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class SortedList : ICloneable, System.Collections.IDictionary
type SortedList = class
    interface IDictionary
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class SortedList
Implements ICloneable, IDictionary
Herencia
SortedListSortedListSortedListSortedList
Atributos
Implementaciones

Ejemplos

En el ejemplo de código siguiente se muestra cómo crear e inicializar un SortedList objeto y cómo imprimir sus claves y valores.The following code example shows how to create and initialize a SortedList object and how to print out its keys and values.

#using <system.dll>

using namespace System;
using namespace System::Collections;
public ref class SamplesSortedList
{
public:
   static void PrintKeysAndValues( SortedList^ myList )
   {
      Console::WriteLine( "\t-KEY-\t-VALUE-" );
      for ( int i = 0; i < myList->Count; i++ )
      {
         Console::WriteLine( "\t{0}:\t{1}", myList->GetKey( i ), myList->GetByIndex( i ) );

      }
      Console::WriteLine();
   }

};

int main()
{

   // Creates and initializes a new SortedList.
   SortedList^ mySL = gcnew SortedList;
   mySL->Add( "Third", "!" );
   mySL->Add( "Second", "World" );
   mySL->Add( "First", "Hello" );

   // Displays the properties and values of the SortedList.
   Console::WriteLine( "mySL" );
   Console::WriteLine( "  Count:    {0}", mySL->Count );
   Console::WriteLine( "  Capacity: {0}", mySL->Capacity );
   Console::WriteLine( "  Keys and Values:" );
   SamplesSortedList::PrintKeysAndValues( mySL );
}

/*
This code produces the following output.

mySL
Count:    3
Capacity: 16
Keys and Values:
-KEY-    -VALUE-
First:    Hello
Second:    World
Third:    !
*/
using System;
using System.Collections;
public class SamplesSortedList  {

   public static void Main()  {

      // Creates and initializes a new SortedList.
      SortedList mySL = new SortedList();
       mySL.Add("Third", "!");
       mySL.Add("Second", "World");
       mySL.Add("First", "Hello");

      // Displays the properties and values of the SortedList.
      Console.WriteLine( "mySL" );
      Console.WriteLine( "  Count:    {0}", mySL.Count );
      Console.WriteLine( "  Capacity: {0}", mySL.Capacity );
      Console.WriteLine( "  Keys and Values:" );
      PrintKeysAndValues( mySL );
   }


   public static void PrintKeysAndValues( SortedList myList )  {
      Console.WriteLine( "\t-KEY-\t-VALUE-" );
      for ( int i = 0; i < myList.Count; i++ )  {
         Console.WriteLine( "\t{0}:\t{1}", myList.GetKey(i), myList.GetByIndex(i) );
      }
      Console.WriteLine();
   }
}
/*
This code produces the following output.

mySL
  Count:    3
  Capacity: 16
  Keys and Values:
    -KEY-    -VALUE-
    First:    Hello
    Second:    World
    Third:    !
*/
Imports System
Imports System.Collections
Imports Microsoft.VisualBasic

Public Class SamplesSortedList    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new SortedList.
        Dim mySL As New SortedList()
        mySL.Add("Third", "!")
        mySL.Add("Second", "World")
        mySL.Add("First", "Hello")
        
        ' Displays the properties and values of the SortedList.
        Console.WriteLine("mySL")
        Console.WriteLine("  Count:    {0}", mySL.Count)
        Console.WriteLine("  Capacity: {0}", mySL.Capacity)
        Console.WriteLine("  Keys and Values:")
        PrintKeysAndValues(mySL)
    End Sub
    
    Public Shared Sub PrintKeysAndValues(myList As SortedList)
        Console.WriteLine(ControlChars.Tab & "-KEY-" & ControlChars.Tab & _
           "-VALUE-")
        Dim i As Integer
        For i = 0 To myList.Count - 1
            Console.WriteLine(ControlChars.Tab & "{0}:" & ControlChars.Tab & _
               "{1}", myList.GetKey(i), myList.GetByIndex(i))
        Next i
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' mySL
'   Count:    3
'   Capacity: 16
'   Keys and Values:
'     -KEY-     -VALUE-
'     First:    Hello
'     Second:   World
'     Third:    !
 

Comentarios

Un SortedList elemento puede tener acceso a su clave, como un elemento en cualquier IDictionary implementación, o por su índice, como un elemento en cualquier IList implementación.A SortedList element can be accessed by its key, like an element in any IDictionary implementation, or by its index, like an element in any IList implementation.

Importante

No se recomienda que utilice el SortedList clase para el nuevo desarrollo.We don't recommend that you use the SortedList class for new development. En su lugar, se recomienda que use el tipo genérico System.Collections.Generic.SortedList<TKey,TValue> clase.Instead, we recommend that you use the generic System.Collections.Generic.SortedList<TKey,TValue> class. Para obtener más información, consulte no deben usarse las colecciones no genéricas en GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Un SortedList objeto mantiene internamente dos matrices para almacenar los elementos de la lista; es decir, una matriz de las claves y otra para los valores asociados.A SortedList object internally maintains two arrays to store the elements of the list; that is, one array for the keys and another array for the associated values. Cada elemento es un par clave/valor que se puede tener acceso como una DictionaryEntry objeto.Each element is a key/value pair that can be accessed as a DictionaryEntry object. No puede ser una clave null, pero puede ser un valor.A key cannot be null, but a value can be.

La capacidad de un SortedList objeto es el número de elementos de la SortedList puede contener.The capacity of a SortedList object is the number of elements the SortedList can hold. Cuando se agregan elementos a un SortedList, automáticamente se aumenta la capacidad según sea necesario mediante la reasignación.As elements are added to a SortedList, the capacity is automatically increased as required through reallocation. La capacidad puede reducirse mediante una llamada a TrimToSize o estableciendo la Capacity propiedad explícitamente.The capacity can be decreased by calling TrimToSize or by setting the Capacity property explicitly.

Solo para .NET framework: Para gran SortedList objetos, puede aumentar la capacidad máxima de 2 millones de elementos en un sistema de 64 bits mediante el establecimiento la enabled atributo de la <gcAllowVeryLargeObjects> elemento de configuración a true en el entorno de tiempo de ejecución..NET Framework only: For very large SortedList objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

Los elementos de un SortedList objetos se ordenan por claves en función de un determinado IComparer implementación que especificó cuando la SortedList está creada, o según el IComparable implementación proporcionada por las propias claves.The elements of a SortedList object are sorted by the keys either according to a specific IComparer implementation specified when the SortedList is created or according to the IComparable implementation provided by the keys themselves. En cualquier caso, un SortedList no se admiten claves duplicadas.In either case, a SortedList does not allow duplicate keys.

La secuencia de índice se basa en la secuencia de ordenación.The index sequence is based on the sort sequence. Cuando se agrega un elemento, éste se inserta en SortedList en la ordenación correcta orden y la indización se ajusta en consecuencia.When an element is added, it is inserted into SortedList in the correct sort order, and the indexing adjusts accordingly. Cuando se quita un elemento, la indización también se ajusta según corresponda.When an element is removed, the indexing also adjusts accordingly. Por lo tanto, puede cambiar el índice de un par de clave y valor específico como elementos se agregan o quitan de la SortedList objeto.Therefore, the index of a specific key/value pair might change as elements are added or removed from the SortedList object.

Operaciones en un SortedList objeto tienden a ser más lento que las operaciones en un Hashtable objeto debido a la ordenación.Operations on a SortedList object tend to be slower than operations on a Hashtable object because of the sorting. Sin embargo, el SortedList ofrece más flexibilidad al permitir el acceso a los valores a través de las claves asociadas o a través de los índices.However, the SortedList offers more flexibility by allowing access to the values either through the associated keys or through the indexes.

Elementos de esta colección se pueden acceder mediante un índice entero.Elements in this collection can be accessed using an integer index. Los índices de esta colección son de base cero.Indexes in this collection are zero-based.

El foreach instrucción del lenguaje C# (for each en Visual Basic) devuelve un objeto del tipo de los elementos de la colección.The foreach statement of the C# language (for each in Visual Basic) returns an object of the type of the elements in the collection. Puesto que cada elemento de la SortedList objeto es un par clave/valor, el tipo de elemento no es el tipo de la clave o el tipo del valor.Since each element of the SortedList object is a key/value pair, the element type is not the type of the key or the type of the value. En su lugar, el tipo de elemento es DictionaryEntry.Rather, the element type is DictionaryEntry. Por ejemplo:For example:

for each (DictionaryEntry de in mySortedList)
{
    //...
}
foreach (DictionaryEntry de in mySortedList)
{
    //...
}
For Each de As DictionaryEntry In mySortedList
    '...
Next de

El foreach instrucción es un contenedor alrededor del enumerador, que permite solo lectura pero no escribir en la colección.The foreach statement is a wrapper around the enumerator, which allows only reading from, not writing to, the collection.

Constructores

SortedList() SortedList() SortedList() SortedList()

Inicializa una nueva instancia de la clase SortedList que está vacía, tiene la capacidad inicial predeterminada y está ordenada en función de la interfaz IComparable implementada por cada clave agregada al objeto SortedList.Initializes a new instance of the SortedList class that is empty, has the default initial capacity, and is sorted according to the IComparable interface implemented by each key added to the SortedList object.

SortedList(IComparer) SortedList(IComparer) SortedList(IComparer) SortedList(IComparer)

Inicializa una nueva instancia de la clase SortedList que está vacía, tiene la capacidad inicial predeterminada y está ordenada de acuerdo con la interfaz IComparer especificada.Initializes a new instance of the SortedList class that is empty, has the default initial capacity, and is sorted according to the specified IComparer interface.

SortedList(IComparer, Int32) SortedList(IComparer, Int32) SortedList(IComparer, Int32) SortedList(IComparer, Int32)

Inicializa una nueva instancia de la clase SortedList que está vacía, tiene la capacidad inicial especificada y está ordenada de acuerdo con la interfaz IComparer especificada.Initializes a new instance of the SortedList class that is empty, has the specified initial capacity, and is sorted according to the specified IComparer interface.

SortedList(IDictionary) SortedList(IDictionary) SortedList(IDictionary) SortedList(IDictionary)

Inicializa una nueva instancia de la clase SortedList que contiene elementos copiados del diccionario especificado, tiene la misma capacidad inicial que el número de elementos copiados y se ordena de acuerdo con la interfaz IComparable implementada por cada clave.Initializes a new instance of the SortedList class that contains elements copied from the specified dictionary, has the same initial capacity as the number of elements copied, and is sorted according to the IComparable interface implemented by each key.

SortedList(IDictionary, IComparer) SortedList(IDictionary, IComparer) SortedList(IDictionary, IComparer) SortedList(IDictionary, IComparer)

Inicializa una nueva instancia de la clase SortedList que contiene elementos copiados del diccionario especificado, tiene la misma capacidad inicial que el número de elementos copiados y se ordena de acuerdo con la interfaz IComparer especificada.Initializes a new instance of the SortedList class that contains elements copied from the specified dictionary, has the same initial capacity as the number of elements copied, and is sorted according to the specified IComparer interface.

SortedList(Int32) SortedList(Int32) SortedList(Int32) SortedList(Int32)

Inicializa una nueva instancia de la clase SortedList que está vacía, tiene la capacidad inicial especificada y está ordenada en función de la interfaz IComparable implementada por cada clave agregada al objeto SortedList.Initializes a new instance of the SortedList class that is empty, has the specified initial capacity, and is sorted according to the IComparable interface implemented by each key added to the SortedList object.

Propiedades

Capacity Capacity Capacity Capacity

Obtiene o establece la capacidad de un objeto SortedList.Gets or sets the capacity of a SortedList object.

Count Count Count Count

Obtiene el número de elementos incluidos en un objeto SortedList.Gets the number of elements contained in a SortedList object.

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Obtiene un valor que indica si un objeto SortedList tiene un tamaño fijo.Gets a value indicating whether a SortedList object has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtiene un valor que indica si un objeto SortedList es de sólo lectura.Gets a value indicating whether a SortedList object is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Obtiene un valor que indica si el acceso a un objeto SortedList está sincronizado (es seguro para la ejecución de subprocesos).Gets a value indicating whether access to a SortedList object is synchronized (thread safe).

Item[Object] Item[Object] Item[Object] Item[Object]

Obtiene o establece el valor asociado a una clave específica de un objeto SortedList.Gets or sets the value associated with a specific key in a SortedList object.

Keys Keys Keys Keys

Obtiene las claves de un objeto SortedList.Gets the keys in a SortedList object.

SyncRoot SyncRoot SyncRoot SyncRoot

Obtiene un objeto que se puede utilizar para sincronizar el acceso a un objeto SortedList.Gets an object that can be used to synchronize access to a SortedList object.

Values Values Values Values

Obtiene los valores de un objeto SortedList.Gets the values in a SortedList object.

Métodos

Add(Object, Object) Add(Object, Object) Add(Object, Object) Add(Object, Object)

Agrega un elemento con la clave y el valor especificados a un objeto SortedList.Adds an element with the specified key and value to a SortedList object.

Clear() Clear() Clear() Clear()

Quita todos los elementos de un objeto SortedList.Removes all elements from a SortedList object.

Clone() Clone() Clone() Clone()

Crea una copia superficial de un objeto SortedList.Creates a shallow copy of a SortedList object.

Contains(Object) Contains(Object) Contains(Object) Contains(Object)

Determina si un objeto SortedList contiene una clave específica.Determines whether a SortedList object contains a specific key.

ContainsKey(Object) ContainsKey(Object) ContainsKey(Object) ContainsKey(Object)

Determina si un objeto SortedList contiene una clave específica.Determines whether a SortedList object contains a specific key.

ContainsValue(Object) ContainsValue(Object) ContainsValue(Object) ContainsValue(Object)

Determina si un objeto SortedList contiene un valor específico.Determines whether a SortedList object contains a specific value.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Copia los elementos SortedList en un objeto Array unidimensional, empezando en el índice especificado de la matriz.Copies SortedList elements to a one-dimensional Array object, starting at the specified index in the array.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetByIndex(Int32) GetByIndex(Int32) GetByIndex(Int32) GetByIndex(Int32)

Obtiene el valor que se encuentra en el índice especificado de un objeto SortedList.Gets the value at the specified index of a SortedList object.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Devuelve un objeto IDictionaryEnumerator que recorre en iteración un objeto SortedList.Returns an IDictionaryEnumerator object that iterates through a SortedList object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetKey(Int32) GetKey(Int32) GetKey(Int32) GetKey(Int32)

Obtiene la clave que se encuentra en el índice especificado de un objeto SortedList.Gets the key at the specified index of a SortedList object.

GetKeyList() GetKeyList() GetKeyList() GetKeyList()

Obtiene las claves de un objeto SortedList.Gets the keys in a SortedList object.

GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
GetValueList() GetValueList() GetValueList() GetValueList()

Obtiene los valores de un objeto SortedList.Gets the values in a SortedList object.

IndexOfKey(Object) IndexOfKey(Object) IndexOfKey(Object) IndexOfKey(Object)

Devuelve el índice de base cero de la clave especificada en un objeto SortedList.Returns the zero-based index of the specified key in a SortedList object.

IndexOfValue(Object) IndexOfValue(Object) IndexOfValue(Object) IndexOfValue(Object)

Devuelve el índice de base cero de la primera aparición del valor especificado en un objeto SortedList.Returns the zero-based index of the first occurrence of the specified value in a SortedList object.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
Remove(Object) Remove(Object) Remove(Object) Remove(Object)

Quita el elemento con la clave especificada de un objeto SortedList.Removes the element with the specified key from a SortedList object.

RemoveAt(Int32) RemoveAt(Int32) RemoveAt(Int32) RemoveAt(Int32)

Quita el elemento en el índice especificado de un objeto SortedList.Removes the element at the specified index of a SortedList object.

SetByIndex(Int32, Object) SetByIndex(Int32, Object) SetByIndex(Int32, Object) SetByIndex(Int32, Object)

Reemplaza el valor de un índice especificado en un objeto SortedList.Replaces the value at a specific index in a SortedList object.

Synchronized(SortedList) Synchronized(SortedList) Synchronized(SortedList) Synchronized(SortedList)

Devuelve un contenedor sincronizado (seguro para la ejecución de subprocesos) para un objeto SortedList.Returns a synchronized (thread-safe) wrapper for a SortedList object.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)
TrimToSize() TrimToSize() TrimToSize() TrimToSize()

Establece la capacidad en el número real de elementos de un objeto SortedList.Sets the capacity to the actual number of elements in a SortedList object.

Implementaciones de interfaz explícitas

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Devuelve un objeto IEnumerator que itera a través del objeto SortedList.Returns an IEnumerator that iterates through the SortedList.

Extension Methods

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Convierte los elementos de IEnumerable en el tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Habilita la paralelización de una consulta.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Convierte una interfaz IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Se aplica a

Seguridad para subprocesos

Estáticos públicos (Shared en Visual Basic) los miembros de este tipo son seguros para subprocesos.Public static (Shared in Visual Basic) members of this type are thread safe. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.Any instance members are not guaranteed to be thread safe.

Un SortedList objeto puede admitir varios lectores simultáneamente, siempre que no se modifica la colección.A SortedList object can support multiple readers concurrently, as long as the collection is not modified. Para garantizar la seguridad para subprocesos de la SortedList, todas las operaciones deben realizarse a través del contenedor devuelto por el Synchronized(SortedList) método.To guarantee the thread safety of the SortedList, all operations must be done through the wrapper returned by the Synchronized(SortedList) method.

Enumerar una colección no es intrínsecamente un procedimiento seguro para subprocesos.Enumerating through a collection is intrinsically not a thread-safe procedure. Incluso cuando una colección está sincronizada, otros subprocesos todavía pueden modificarla, lo que hace que el enumerador produzca una excepción.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Con el fin de garantizar la seguridad para la ejecución de subprocesos durante la enumeración, se puede bloquear la colección durante toda la enumeración o detectar las excepciones resultantes de los cambios realizados por otros subprocesos.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Consulte también: