SortedList Classe

Definição

Namespace:

System.Collections

Assembly:

System.Collections.NonGeneric.dll

Origem:

SortedList.cs

Representa uma coleção de pares chave/valor que são classificados pelas chaves e são acessíveis por chave e 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

Herança

Object

SortedList

Implementações

ICollection IDictionary IEnumerable ICloneable

Exemplos

O exemplo de código a seguir mostra como criar e inicializar um SortedList objeto e como imprimir suas chaves e 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:    !

Comentários

Um SortedList elemento pode ser acessado por sua chave, como um elemento em qualquer IDictionary implementação ou por seu índice, como um elemento em qualquer IList implementação.

Importante

Não recomendamos que você use a SortedList classe para desenvolvimento novo. Em vez disso, recomendamos que você use a classe genérica System.Collections.Generic.SortedList<TKey,TValue> . Para obter mais informações, consulte Coleções não genéricas não devem ser usadas no GitHub.

Um SortedList objeto mantém internamente duas matrizes para armazenar os elementos da lista; ou seja, uma matriz para as chaves e outra matriz para os valores associados. Cada elemento é um par chave/valor que pode ser acessado como um DictionaryEntry objeto . Uma chave não pode ser null, mas um valor pode ser.

A capacidade de um SortedList objeto é o número de elementos que o SortedList pode conter. À medida que os elementos são adicionados a um SortedList, a capacidade é aumentada automaticamente conforme necessário por meio da realocação. A capacidade pode ser reduzida chamando TrimToSize ou definindo a Capacity propriedade explicitamente.

.NET Framework apenas: para objetos muito grandesSortedList, você pode aumentar a capacidade máxima para 2 bilhões de elementos em um sistema de 64 bits definindo o enabled atributo do elemento de <gcAllowVeryLargeObjects> configuração como true no ambiente de tempo de execução.

Os elementos de um SortedList objeto são classificados pelas chaves de acordo com uma implementação específica IComparer especificada quando o SortedList é criado ou de acordo com a IComparable implementação fornecida pelas próprias chaves. Em ambos os casos, um SortedList não permite chaves duplicadas.

A sequência de índice é baseada na sequência de classificação. Quando um elemento é adicionado, ele é inserido SortedList na ordem de classificação correta e a indexação é ajustada adequadamente. Quando um elemento é removido, a indexação também é ajustada adequadamente. Portanto, o índice de um par chave/valor específico pode mudar à medida que os elementos são adicionados ou removidos do SortedList objeto .

As operações em um SortedList objeto tendem a ser mais lentas do que as operações em um Hashtable objeto devido à classificação. No entanto, o SortedList oferece mais flexibilidade permitindo o acesso aos valores por meio das chaves associadas ou por meio dos índices.

Os elementos nesta coleção podem ser acessados usando um índice inteiro. Os índices nesta coleção são baseados em zero.

A foreach instrução da linguagem C# (for each no Visual Basic) retorna um objeto do tipo dos elementos na coleção. Como cada elemento do SortedList objeto é um par chave/valor, o tipo de elemento não é o tipo da chave ou o tipo do valor. Em vez disso, o tipo de elemento é DictionaryEntry. Por exemplo:

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

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

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

A foreach instrução é um wrapper ao redor do enumerador, que permite apenas a leitura, não a gravação na coleção.

Construtores

SortedList()	Inicializa uma nova instância da classe SortedList que está vazia, tem a capacidade inicial padrão e é classificada de acordo com a interface IComparable implementada por cada chave adicionada ao objeto SortedList.
SortedList(IComparer)	Inicializa uma nova instância da classe SortedList que está vazia, tem a capacidade inicial padrão e é classificada de acordo com a interface IComparer especificada.
SortedList(IComparer, Int32)	Inicializa uma nova instância da classe SortedList que está vazia, tem a capacidade inicial especificada e é classificada de acordo com a interface IComparer especificada.
SortedList(IDictionary)	Inicializa uma nova instância da classe SortedList que contém elementos copiados do dicionário especificado, tem a mesma capacidade inicial que o número de elementos copiados e é classificada segundo a interface IComparable implementada por cada chave.
SortedList(IDictionary, IComparer)	Inicializa uma nova instância da classe SortedList que contém elementos copiados do dicionário especificado, tem a mesma capacidade inicial que o número de elementos copiados e é classificada segundo a interface IComparer especificada.
SortedList(Int32)	Inicializa uma nova instância da classe SortedList que está vazia, tem a capacidade inicial especificada e é classificada de acordo com a interface IComparable implementada por cada chave adicionada ao objeto SortedList.

Propriedades

Capacity	Obtém ou define a capacidade de um objeto SortedList.
Count	Obtém o número de elementos contidos em um objeto SortedList.
IsFixedSize	Obtém um valor que indica se o objeto SortedList tem um tamanho fixo.
IsReadOnly	Obtém um valor que indica se um objeto SortedList é somente leitura.
IsSynchronized	Obtém um valor que indica se o acesso a um objeto SortedList é sincronizado (thread-safe).
Item[Object]	Obtém ou define o valor associado com uma chave específica em um objeto SortedList.
Keys	Obtém as chaves em um objeto SortedList.
SyncRoot	Obtém um objeto que pode ser usado para sincronizar o acesso a um objeto SortedList.
Values	Obtém os valores em um objeto SortedList.

Métodos

Add(Object, Object)	Adiciona um elemento com a chave e o valor especificados a um objeto SortedList.
Clear()	Remove todos os elementos de um objeto SortedList.
Clone()	Cria uma cópia superficial de um objeto SortedList.
Contains(Object)	Determina se um objeto SortedList contém uma chave específica.
ContainsKey(Object)	Determina se um objeto SortedList contém uma chave específica.
ContainsValue(Object)	Determina se um objeto SortedList contém um valor específico.
CopyTo(Array, Int32)	Copia SortedList elementos para um objeto Array unidimensional, iniciando no índice especificado na matriz.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetByIndex(Int32)	Obtém o valor no índice especificado de um objeto SortedList.
GetEnumerator()	Retorna um objeto IDictionaryEnumerator que itera por um objeto SortedList.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetKey(Int32)	Obtém a chave no índice especificado de um objeto SortedList.
GetKeyList()	Obtém as chaves em um objeto SortedList.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetValueList()	Obtém os valores em um objeto SortedList.
IndexOfKey(Object)	Retorna o índice baseado em zero da chave especificada em um objeto SortedList.
IndexOfValue(Object)	Retorna o índice baseado em zero da primeira ocorrência do valor especificado em um objeto SortedList.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Remove(Object)	Remove o elemento com a chave especificada de um objeto SortedList.
RemoveAt(Int32)	Remove o elemento no índice especificado de um objeto SortedList.
SetByIndex(Int32, Object)	Substitui o valor em um índice específico em um objeto SortedList.
Synchronized(SortedList)	Retorna o wrapper sincronizado (thread-safe) para um objeto SortedList.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TrimToSize()	Define a capacidade para o número real de elementos em um objeto SortedList.

Implantações explícitas de interface

IEnumerable.GetEnumerator()

Retorna um IEnumerator que itera pelo SortedList.

Métodos de Extensão

Cast<TResult>(IEnumerable)	Converte os elementos de um IEnumerable para o tipo especificado.
OfType<TResult>(IEnumerable)	Filtra os elementos de um IEnumerable com base em um tipo especificado.
AsParallel(IEnumerable)	Habilita a paralelização de uma consulta.
AsQueryable(IEnumerable)	Converte um IEnumerable em um IQueryable.

Acesso thread-safe

Os membros estáticos públicos (Shared no Visual Basic) desse são thread-safe. Não há garantia de que qualquer membro de instância seja seguro para threads.

Um SortedList objeto pode dar suporte a vários leitores simultaneamente, desde que a coleção não seja modificada. Para garantir a segurança de thread do SortedList, todas as operações devem ser feitas por meio do wrapper retornado pelo Synchronized(SortedList) método .

A enumeração por meio de uma coleção não é um procedimento thread-safe intrínseco. Mesmo quando uma coleção está sincronizada, outros threads ainda podem modificar a coleção, o que faz o enumerador lançar uma exceção. Para garantir thread-safe durante a enumeração, é possível bloquear a coleção durante toda a enumeração ou verificar as exceções resultantes das alterações feitas por outros threads.

Confira também

• IComparable
• IComparer
• IDictionary
• Hashtable
• SortedList<TKey,TValue>
• Executando operações de cadeia de caracteres Culture-Insensitive em coleções