SortedList Clase

Definición

Espacio de nombres:

System.Collections

Ensamblado:

System.Collections.NonGeneric.dll

Source:

SortedList.cs

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.

public ref class SortedList : ICloneable, System::Collections::IDictionary

public class SortedList : ICloneable, System.Collections.IDictionary

type SortedList = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable

Public Class SortedList
Implements ICloneable, IDictionary

Herencia

Object

SortedList

Implementaciones

ICollection IDictionary IEnumerable ICloneable

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.

#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 SamplesSortedList2
{
    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.Collections

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

Se puede acceder a un SortedList elemento mediante su clave, como un elemento en cualquier IDictionary implementación, o por su índice, como un elemento de cualquier IList implementación.

Importante

No se recomienda usar la SortedList clase para el nuevo desarrollo. En su lugar, se recomienda usar la clase genérica System.Collections.Generic.SortedList<TKey,TValue> . Para obtener más información, consulte No se deben usar colecciones no genéricas en GitHub.

Un SortedList objeto mantiene internamente dos matrices para almacenar los elementos de la lista; es decir, una matriz para las claves y otra matriz para los valores asociados. Cada elemento es un par clave-valor al que se puede acceder como un DictionaryEntry objeto. Una clave no puede ser null, pero un valor puede ser .

La capacidad de un SortedList objeto es el número de elementos que SortedList puede contener. A medida que se agregan elementos a , SortedListla capacidad aumenta automáticamente según sea necesario mediante la reasignación. La capacidad se puede reducir llamando a TrimToSize o estableciendo la Capacity propiedad explícitamente.

Solo .NET Framework: En el caso de objetos muy grandesSortedList, puede aumentar la capacidad máxima a 2 mil millones de elementos en un sistema de 64 bits estableciendo el enabled atributo del elemento true de <gcAllowVeryLargeObjects> configuración en en el entorno en tiempo de ejecución.

Los elementos de un SortedList objeto se ordenan por las claves según una implementación específica especificada IComparer cuando SortedList se crea o según la IComparable implementación proporcionada por las propias claves. En cualquier caso, un SortedList no permite claves duplicadas.

La secuencia de índice se basa en la secuencia de ordenación. Cuando se agrega un elemento, se inserta en SortedList en el criterio de ordenación correcto y la indexación se ajusta en consecuencia. Cuando se quita un elemento, la indexación también se ajusta en consecuencia. Por lo tanto, el índice de un par clave-valor específico puede cambiar a medida que se agregan o quitan elementos del SortedList objeto.

Las operaciones en un SortedList objeto tienden a ser más lentas que las operaciones de un Hashtable objeto debido a la ordenación. Sin embargo, ofrece SortedList más flexibilidad al permitir el acceso a los valores a través de las claves asociadas o a través de los índices.

Se puede tener acceso a los elementos de esta colección mediante un índice entero. Los índices de esta colección se basan en cero.

La foreach instrucción del lenguaje C# (for each en Visual Basic) devuelve un objeto del tipo de los elementos de la colección. Dado que cada elemento del SortedList objeto es un par clave-valor, el tipo de elemento no es el tipo de la clave o el tipo del valor. En su lugar, el tipo de elemento es DictionaryEntry. Por ejemplo:

for each (DictionaryEntry de in mySortedList)
{
    //...
}

foreach (DictionaryEntry de in mySortedList)
{
    //...
}

For Each de As DictionaryEntry In mySortedList
    '...
Next de

La foreach instrucción es un contenedor alrededor del enumerador, que solo permite leer, no escribir en la colección.

Constructores

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.
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.
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.
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.
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.
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.

Propiedades

Capacity	Obtiene o establece la capacidad de un objeto SortedList.
Count	Obtiene el número de elementos incluidos en un objeto SortedList.
IsFixedSize	Obtiene un valor que indica si un objeto SortedList tiene un tamaño fijo.
IsReadOnly	Obtiene un valor que indica si un objeto SortedList es de solo lectura.
IsSynchronized	Obtiene un valor que indica si el acceso a un objeto SortedList está sincronizado (es seguro para subprocesos).
Item[Object]	Obtiene o establece el valor asociado a una clave específica de un objeto SortedList.
Keys	Obtiene las claves de un objeto SortedList.
SyncRoot	Obtiene un objeto que se puede utilizar para sincronizar el acceso a un objeto SortedList.
Values	Obtiene los valores de un objeto SortedList.

Métodos

Add(Object, Object)	Agrega un elemento con la clave y el valor especificados a un objeto SortedList.
Clear()	Quita todos los elementos de un objeto SortedList.
Clone()	Crea una copia superficial de un objeto SortedList.
Contains(Object)	Determina si un objeto SortedList contiene una clave específica.
ContainsKey(Object)	Determina si un objeto SortedList contiene una clave específica.
ContainsValue(Object)	Determina si un objeto SortedList contiene un valor específico.
CopyTo(Array, Int32)	Copia los elementos SortedList en un objeto Array unidimensional, empezando en el índice especificado de la matriz.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetByIndex(Int32)	Obtiene el valor que se encuentra en el índice especificado de un objeto SortedList.
GetEnumerator()	Devuelve un objeto IDictionaryEnumerator que itera por un objeto SortedList.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetKey(Int32)	Obtiene la clave que se encuentra en el índice especificado de un objeto SortedList.
GetKeyList()	Obtiene las claves de un objeto SortedList.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
GetValueList()	Obtiene los valores de un objeto SortedList.
IndexOfKey(Object)	Devuelve el índice de base cero de la clave especificada en un objeto SortedList.
IndexOfValue(Object)	Devuelve el índice de base cero de la primera aparición del valor especificado en un objeto SortedList.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
Remove(Object)	Quita el elemento con la clave especificada de un objeto SortedList.
RemoveAt(Int32)	Quita el elemento en el índice especificado de un objeto SortedList.
SetByIndex(Int32, Object)	Reemplaza el valor de un índice especificado en un objeto SortedList.
Synchronized(SortedList)	Devuelve un contenedor sincronizado (seguro para subprocesos) para un objeto SortedList.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
TrimToSize()	Establece la capacidad en el número real de elementos de un objeto SortedList.

Implementaciones de interfaz explícitas

IEnumerable.GetEnumerator()

Devuelve un objeto IEnumerator que itera a través del objeto SortedList.

Métodos de extensión

Cast<TResult>(IEnumerable)	Convierte los elementos de IEnumerable en el tipo especificado.
OfType<TResult>(IEnumerable)	Filtra los elementos de IEnumerable en función de un tipo especificado.
AsParallel(IEnumerable)	Habilita la paralelización de una consulta.
AsQueryable(IEnumerable)	Convierte una interfaz IEnumerable en IQueryable.

Seguridad para subprocesos

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

Un SortedList objeto puede admitir varios lectores simultáneamente, siempre y cuando no se modifique la colección. Para garantizar la seguridad de subprocesos de SortedList, todas las operaciones deben realizarse a través del contenedor devuelto por el Synchronized(SortedList) método .

Enumerar una colección no es intrínsecamente un procedimiento seguro para subprocesos. Incluso cuando una colección está sincronizada, otros subprocesos todavía pueden modificarla, lo que hace que el enumerador produzca una excepción. 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.

Consulte también

• IComparable
• IComparer
• IDictionary
• Hashtable
• SortedList<TKey,TValue>
• Realizar operaciones de cadenas que no tienen en cuenta las referencias culturales en colecciones