SortedList SortedList SortedList SortedList Class

Definição

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

Exemplos

O exemplo de código a seguir mostra como criar e inicializar SortedList um objeto e como imprimir suas chaves e 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.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 IDictionary em qualquer implementação ou por seu índice, como um elemento em IList qualquer implementação.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

Não recomendamos que você use a SortedList classe para o novo desenvolvimento.We don't recommend that you use the SortedList class for new development. Em vez disso, recomendamos que você use System.Collections.Generic.SortedList<TKey,TValue> a classe genérica.Instead, we recommend that you use the generic System.Collections.Generic.SortedList<TKey,TValue> class. Para obter mais informações, consulte coleções não genéricas não devem ser usadas no github.For more information, see Non-generic collections shouldn't be used on 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.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 é um par de chave/valor que pode ser acessado como um DictionaryEntry objeto.Each element is a key/value pair that can be accessed as a DictionaryEntry object. Uma chave não pode nullser, mas um valor pode ser.A key cannot be null, but a value can be.

A capacidade de um SortedList objeto é o número de elementos que SortedList o pode conter.The capacity of a SortedList object is the number of elements the SortedList can hold. À medida que os elementos são SortedListadicionados a um, a capacidade é aumentada automaticamente conforme necessário por meio de realocação.As elements are added to a SortedList, the capacity is automatically increased as required through reallocation. A capacidade pode ser diminuída chamando TrimToSize ou definindo explicitamente a Capacity propriedade.The capacity can be decreased by calling TrimToSize or by setting the Capacity property explicitly.

Somente .NET Framework: Para objetos muito SortedList grandes, você pode aumentar a capacidade máxima para 2.000.000.000 elementos em um sistema de 64 bits definindo o enabled atributo do elemento de <gcAllowVeryLargeObjects> configuração para true no ambiente de tempo de execução..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.

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.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. Em ambos os casos, SortedList um não permite chaves duplicadas.In either case, a SortedList does not allow duplicate keys.

A sequência de índice é baseada na sequência de classificação.The index sequence is based on the sort sequence. Quando um elemento é adicionado, ele é inserido SortedList na ordem de classificação correta e a indexação ajusta-se adequadamente.When an element is added, it is inserted into SortedList in the correct sort order, and the indexing adjusts accordingly. Quando um elemento é removido, a indexação também se ajusta de acordo.When an element is removed, the indexing also adjusts accordingly. Portanto, o índice de um par chave/valor específico pode ser alterado à medida que elementos são adicionados ou SortedList removidos do objeto.Therefore, the index of a specific key/value pair might change as elements are added or removed from the SortedList object.

As operações em SortedList um objeto tendem a ser mais lentas do que Hashtable as operações em um objeto devido à classificação.Operations on a SortedList object tend to be slower than operations on a Hashtable object because of the sorting. No entanto SortedList , o oferece mais flexibilidade, permitindo o acesso aos valores por meio de chaves associadas ou por meio de índices.However, the SortedList offers more flexibility by allowing access to the values either through the associated keys or through the indexes.

Elementos nesta coleção podem ser acessados usando um índice de número inteiro.Elements in this collection can be accessed using an integer index. Os índices nesta coleção são baseados em zero.Indexes in this collection are zero-based.

A foreach instrução do C# idioma (for each em Visual Basic) retorna um objeto do tipo dos elementos na coleção.The foreach statement of the C# language (for each in Visual Basic) returns an object of the type of the elements in the collection. 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.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. Em vez disso, o tipo DictionaryEntryde elemento é.Rather, the element type is DictionaryEntry. Por exemplo:For example:

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 em volta do enumerador, que permite apenas a leitura, e não a gravação, da coleção.The foreach statement is a wrapper around the enumerator, which allows only reading from, not writing to, the collection.

Construtores

SortedList() SortedList() SortedList() 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.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 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.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 uma nova instância da classe SortedList que está vazia, tem a capacidade inicial especificada e é classificada de acordo com a interface 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 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.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 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.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 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.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.

Propriedades

Capacity Capacity Capacity Capacity

Obtém ou define a capacidade de um objeto SortedList.Gets or sets the capacity of a SortedList object.

Count Count Count Count

Obtém o número de elementos contidos em um objeto SortedList.Gets the number of elements contained in a SortedList object.

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Obtém um valor que indica se o objeto SortedList tem um tamanho fixo.Gets a value indicating whether a SortedList object has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtém um valor que indica se um objeto SortedList é somente leitura.Gets a value indicating whether a SortedList object is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Obtém um valor que indica se o acesso a um objeto SortedList é sincronizado (thread-safe).Gets a value indicating whether access to a SortedList object is synchronized (thread safe).

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

Obtém ou define o valor associado com uma chave específica em um objeto SortedList.Gets or sets the value associated with a specific key in a SortedList object.

Keys Keys Keys Keys

Obtém as chaves em um objeto SortedList.Gets the keys in a SortedList object.

SyncRoot SyncRoot SyncRoot SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso a um objeto SortedList.Gets an object that can be used to synchronize access to a SortedList object.

Values Values Values Values

Obtém os valores em um objeto SortedList.Gets the values in a SortedList object.

Métodos

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

Adiciona um elemento com a chave e o valor especificados a um objeto SortedList.Adds an element with the specified key and value to a SortedList object.

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

Remove todos os elementos de um objeto SortedList.Removes all elements from a SortedList object.

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

Cria uma cópia superficial de um objeto SortedList.Creates a shallow copy of a SortedList object.

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

Determina se um objeto SortedList contém uma chave específica.Determines whether a SortedList object contains a specific key.

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

Determina se um objeto SortedList contém uma chave específica.Determines whether a SortedList object contains a specific key.

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

Determina se um objeto SortedList contém um 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 SortedList elementos para um objeto Array unidimensional, iniciando no índice especificado na 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 se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Obtém o valor no índice especificado de um objeto SortedList.Gets the value at the specified index of a SortedList object.

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

Retorna um objeto IDictionaryEnumerator que itera por um objeto SortedList.Returns an IDictionaryEnumerator object that iterates through a SortedList object.

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

Serve como a função de hash padrão.Serves as the default hash function.

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

Obtém a chave no índice especificado de um objeto SortedList.Gets the key at the specified index of a SortedList object.

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

Obtém as chaves em um objeto SortedList .Gets the keys in a SortedList object.

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

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Obtém os valores em um objeto SortedList.Gets the values in a SortedList object.

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

Retorna o índice baseado em zero da chave especificada em um objeto SortedList.Returns the zero-based index of the specified key in a SortedList object.

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

Retorna o índice baseado em zero da primeira ocorrência do valor especificado em um objeto SortedList.Returns the zero-based index of the first occurrence of the specified value in a SortedList object.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Remove o elemento com a chave especificada de um objeto SortedList.Removes the element with the specified key from a SortedList object.

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

Remove o elemento no índice especificado de um 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)

Substitui o valor em um índice específico em um objeto SortedList.Replaces the value at a specific index in a SortedList object.

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

Retorna o wrapper sincronizado (thread-safe) para um objeto SortedList.Returns a synchronized (thread-safe) wrapper for a SortedList object.

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

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

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

Define a capacidade para o número real de elementos em um objeto SortedList.Sets the capacity to the actual number of elements in a SortedList object.

Implantações explícitas de interface

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

Retorna um IEnumerator que itera pelo SortedList.Returns an IEnumerator that iterates through the SortedList.

Métodos de Extensão

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

Converte os elementos de um IEnumerable para o 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 os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

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

Habilita a paralelização de uma consulta.Enables parallelization of a query.

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

Converte um IEnumerable em um IQueryable.Converts an IEnumerable to an IQueryable.

Aplica-se a

Acesso thread-safe

Os membros estáticos públicos (Shared no Visual Basic) desse são thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Não há garantia de que qualquer membro de instância seja thread-safe.Any instance members are not guaranteed to be thread safe.

Um SortedList objeto pode dar suporte a vários leitores simultaneamente, desde que a coleção não seja modificada.A SortedList object can support multiple readers concurrently, as long as the collection is not modified. Para garantir a segurança do thread do SortedList, todas as operações devem ser feitas por meio do wrapper retornado Synchronized(SortedList) pelo método.To guarantee the thread safety of the SortedList, all operations must be done through the wrapper returned by the Synchronized(SortedList) method.

A enumeração por meio de uma coleção não é um procedimento thread-safe intrínseco.Enumerating through a collection is intrinsically not a thread-safe procedure. 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.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.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.

Veja também