SortedDictionary<TKey,TValue> Classe

Definição

Representa uma coleção de pares chave/valor que são classificados na chave.Represents a collection of key/value pairs that are sorted on the key.

generic <typename TKey, typename TValue>
public ref class SortedDictionary : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IDictionary<TKey, TValue>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyCollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyDictionary<TKey, TValue>, System::Collections::IDictionary
[System.Serializable]
public class SortedDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>, System.Collections.IDictionary
type SortedDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface IDictionary
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
Public Class SortedDictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue)

Parâmetros de tipo

TKey

O tipo das chaves no dicionário.The type of the keys in the dictionary.

TValue

O tipo dos valores no dicionário.The type of the values in the dictionary.

Herança
SortedDictionary<TKey,TValue>
Atributos
Implementações

Exemplos

O exemplo de código a seguir cria um SortedDictionary<TKey,TValue> vazio de cadeias de caracteres com chaves de cadeias e usa o método Add para adicionar alguns elementos.The following code example creates an empty SortedDictionary<TKey,TValue> of strings with string keys and uses the Add method to add some elements. O exemplo demonstra que o método Add gera um ArgumentException ao tentar adicionar uma chave duplicada.The example demonstrates that the Add method throws an ArgumentException when attempting to add a duplicate key.

O exemplo usa a propriedade Item[TKey] (o indexador em C#) para recuperar valores, demonstrando que um KeyNotFoundException é gerado quando uma chave solicitada não está presente e mostrando que o valor associado a uma chave pode ser substituído.The example uses the Item[TKey] property (the indexer in C#) to retrieve values, demonstrating that a KeyNotFoundException is thrown when a requested key is not present, and showing that the value associated with a key can be replaced.

O exemplo mostra como usar o TryGetValue método como uma forma mais eficiente para recuperar valores, se um programa geralmente deve tentar valores de chave que não estão no dicionário e ele mostra como usar o ContainsKey método para testar se uma chave existe antes de chamar o Add método.The example shows how to use the TryGetValue method as a more efficient way to retrieve values if a program often must try key values that are not in the dictionary, and it shows how to use the ContainsKey method to test whether a key exists before calling the Add method.

O exemplo mostra como enumerar as chaves e os valores no dicionário e como enumerar as chaves e os valores sozinhos usando a propriedade Keys e a propriedade Values.The example shows how to enumerate the keys and values in the dictionary and how to enumerate the keys and values alone using the Keys property and the Values property.

Por fim, o exemplo demonstra o método Remove.Finally, the example demonstrates the Remove method.

using System;
using System.Collections.Generic;

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

        // Add some elements to the dictionary. 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 dictionary.
        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 dictionary.
        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 dictionary, 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 dictionary 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.
        SortedDictionary<string, string>.ValueCollection valueColl = 
            openWith.Values;

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

        // To get the keys alone, use the Keys property.
        SortedDictionary<string, string>.KeyCollection keyColl = 
            openWith.Keys;

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

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

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

Remove("doc")
Key "doc" is not found.
 */
Imports System.Collections.Generic

Public Class Example
    
    Public Shared Sub Main() 

        ' Create a new sorted dictionary of strings, with string 
        ' keys. 
        Dim openWith As New SortedDictionary(Of String, String)
        
        ' Add some elements to the dictionary. 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 dictionary.
        Try
            openWith.Add("txt", "winword.exe")
        Catch 
            Console.WriteLine("An element with Key = ""txt"" already exists.")
        End Try

        ' The Item property is the default property, so you 
        ' can omit its name when accessing elements. 
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' The default Item property 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 default Item property
        ' for that key adds a new key/value pair.
        openWith("doc") = "winword.exe"

        ' The default Item property throws an exception if the requested
        ' key is not in the dictionary.
        Try
            Console.WriteLine("For key = ""tif"", value = {0}.", _
                openWith("tif"))
        Catch 
            Console.WriteLine("Key = ""tif"" is not found.")
        End Try

        ' When a program often has to try keys that turn out not to
        ' be in the dictionary, TryGetValue can be a more efficient 
        ' way to retrieve values.
        Dim value As String = ""
        If openWith.TryGetValue("tif", value) Then
            Console.WriteLine("For key = ""tif"", value = {0}.", value)
        Else
            Console.WriteLine("Key = ""tif"" is not found.")
        End If

        ' ContainsKey can be used to test keys before inserting 
        ' them.
        If Not openWith.ContainsKey("ht") Then
            openWith.Add("ht", "hypertrm.exe")
            Console.WriteLine("Value added for key = ""ht"": {0}", _
                openWith("ht"))
        End If

        ' When you use foreach to enumerate dictionary elements,
        ' the elements are retrieved as KeyValuePair objects.
        Console.WriteLine()
        For Each kvp As KeyValuePair(Of String, String) In openWith
            Console.WriteLine("Key = {0}, Value = {1}", _
                kvp.Key, kvp.Value)
        Next kvp

        ' To get the values alone, use the Values property.
        Dim valueColl _
            As SortedDictionary(Of String, String).ValueCollection = _
            openWith.Values
        
        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for dictionary values.
        Console.WriteLine()
        For Each s As String In valueColl 
            Console.WriteLine("Value = {0}", s)
        Next s

        ' To get the keys alone, use the Keys property.
        Dim keyColl _
            As SortedDictionary(Of String, String).KeyCollection = _
            openWith.Keys
        
        ' The elements of the KeyCollection are strongly typed
        ' with the type that was specified for dictionary keys.
        Console.WriteLine()
        For Each s As String In keyColl 
            Console.WriteLine("Key = {0}", s)
        Next s

        ' Use the Remove method to remove a key/value pair.
        Console.WriteLine(vbLf + "Remove(""doc"")")
        openWith.Remove("doc")
        
        If Not openWith.ContainsKey("doc") Then
            Console.WriteLine("Key ""doc"" is not found.")
        End If

    End Sub

End Class

' 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
'
'Key = bmp
'Key = dib
'Key = doc
'Key = ht
'Key = rtf
'Key = txt
'
'Remove("doc")
'Key "doc" is not found.
' 

Comentários

A classe genérica SortedDictionary<TKey,TValue> é uma árvore de pesquisa binária com a recuperação O (log n), em que n é o número de elementos no dicionário.The SortedDictionary<TKey,TValue> generic class is a binary search tree with O(log n) retrieval, where n is the number of elements in the dictionary. Nesse sentido, ele é semelhante ao SortedList<TKey,TValue> classe genérica.In this respect, it is similar to the SortedList<TKey,TValue> generic class. As duas classes têm modelos de objeto semelhantes e ambos têm a recuperação O (log n).The two classes have similar object models, and both have O(log n) retrieval. Onde as duas classes diferem no uso de memória e na velocidade de inserção e remoção:Where the two classes differ is in memory use and speed of insertion and removal:

Cada par chave/valor pode ser recuperado como uma estrutura KeyValuePair<TKey,TValue> ou como um DictionaryEntry por meio da interface de IDictionary não genérica.Each key/value pair can be retrieved as a KeyValuePair<TKey,TValue> structure, or as a DictionaryEntry through the nongeneric IDictionary interface.

As chaves devem ser imutáveis contanto que sejam usadas como chaves no SortedDictionary<TKey,TValue>.Keys must be immutable as long as they are used as keys in the SortedDictionary<TKey,TValue>. Todas as chaves em um SortedDictionary<TKey,TValue> devem ser exclusivas.Every key in a SortedDictionary<TKey,TValue> must be unique. Uma chave não pode ser null, mas um valor pode ser, se o tipo de valor TValue for um tipo de referência.A key cannot be null, but a value can be, if the value type TValue is a reference type.

SortedDictionary<TKey,TValue> requer uma implementação de comparador para executar comparações de chave.SortedDictionary<TKey,TValue> requires a comparer implementation to perform key comparisons. Você pode especificar uma implementação do IComparer<T> interface genérica usando um construtor que aceita um parâmetro comparer; Se você não especificar uma implementação, o Comparer<T>.Default padrão GenericComparer será usado.You can specify an implementation of the IComparer<T> generic interface by using a constructor that accepts a comparer parameter; if you do not specify an implementation, the default genericcomparer Comparer<T>.Default is used. Se o tipo TKey implementar a interface genérica System.IComparable<T>, o comparador padrão usará essa implementação.If type TKey implements the System.IComparable<T> generic interface, the default comparer uses that implementation.

A instrução foreach do C# idioma (for each no C++, For Each no Visual Basic) retorna um objeto do tipo dos elementos na coleção.The foreach statement of the C# language (for each in C++, For Each in Visual Basic) returns an object of the type of the elements in the collection. Como cada elemento da SortedDictionary<TKey,TValue> é um par chave/valor, o tipo de elemento não é o tipo da chave ou o tipo do valor.Since each element of the SortedDictionary<TKey,TValue> 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 de elemento é KeyValuePair<TKey,TValue>.Instead, the element type is KeyValuePair<TKey,TValue>. O código a seguir C#mostra C++, e Visual Basic sintaxe.The following code shows C#, C++, and Visual Basic syntax.

for each(KeyValuePair<String^, String^> kvp in myDictionary)
{
    Console::WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
foreach( KeyValuePair<string, string> kvp in myDictionary )
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
For Each kvp As KeyValuePair(Of String, String) In myDictionary
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value)
Next kvp

A instrução foreach é um wrapper em volta do enumerador, que permite somente a leitura da coleção, não a gravação nela.The foreach statement is a wrapper around the enumerator, which allows only reading from the collection, not writing to it.

Construtores

SortedDictionary<TKey,TValue>()

Inicializa uma nova instância da classe SortedDictionary<TKey,TValue> que está vazia e usa a implementação IComparer<T> padrão para o tipo de chave.Initializes a new instance of the SortedDictionary<TKey,TValue> class that is empty and uses the default IComparer<T> implementation for the key type.

SortedDictionary<TKey,TValue>(IComparer<TKey>)

Inicializa uma nova instância da classe SortedDictionary<TKey,TValue> que está vazia e usa a implementação IComparer<T> especificada para comparar as chaves.Initializes a new instance of the SortedDictionary<TKey,TValue> class that is empty and uses the specified IComparer<T> implementation to compare keys.

SortedDictionary<TKey,TValue>(IDictionary<TKey,TValue>)

Inicializa uma nova instância da classe SortedDictionary<TKey,TValue> que contém os elementos copiados do IDictionary<TKey,TValue> especificado e usa a implementação IComparer<T> padrão para o tipo de chave.Initializes a new instance of the SortedDictionary<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue> and uses the default IComparer<T> implementation for the key type.

SortedDictionary<TKey,TValue>(IDictionary<TKey,TValue>, IComparer<TKey>)

Inicializa uma nova instância da classe SortedDictionary<TKey,TValue> que contém elementos copiados do IDictionary<TKey,TValue> especificado e usa a implementação IComparer<T> especificada para comparar chaves.Initializes a new instance of the SortedDictionary<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue> and uses the specified IComparer<T> implementation to compare keys.

Propriedades

Comparer

Obtém o IComparer<T> usado para ordenar os elementos do SortedDictionary<TKey,TValue>.Gets the IComparer<T> used to order the elements of the SortedDictionary<TKey,TValue>.

Count

Obtém o número de pares chave-valor contidos no SortedDictionary<TKey,TValue>.Gets the number of key/value pairs contained in the SortedDictionary<TKey,TValue>.

Item[TKey]

Obtém ou define o valor associado à chave especificada.Gets or sets the value associated with the specified key.

Keys

Obtém uma coleção que contém as chaves do SortedDictionary<TKey,TValue>.Gets a collection containing the keys in the SortedDictionary<TKey,TValue>.

Values

Obtém uma coleção que contém os valores no SortedDictionary<TKey,TValue>.Gets a collection containing the values in the SortedDictionary<TKey,TValue>.

Métodos

Add(TKey, TValue)

Adiciona um elemento com a chave e o valor especificados ao SortedDictionary<TKey,TValue>.Adds an element with the specified key and value into the SortedDictionary<TKey,TValue>.

Clear()

Remove todos os elementos do SortedDictionary<TKey,TValue>.Removes all elements from the SortedDictionary<TKey,TValue>.

ContainsKey(TKey)

Determina se o SortedDictionary<TKey,TValue> contém um elemento com a chave especificada.Determines whether the SortedDictionary<TKey,TValue> contains an element with the specified key.

ContainsValue(TValue)

Determina se o SortedDictionary<TKey,TValue> contém um elemento com o valor especificado.Determines whether the SortedDictionary<TKey,TValue> contains an element with the specified value.

CopyTo(KeyValuePair<TKey,TValue>[], Int32)

Copia os elementos da SortedDictionary<TKey,TValue> para a matriz especificada de estruturas KeyValuePair<TKey,TValue>, começando no índice especificado.Copies the elements of the SortedDictionary<TKey,TValue> to the specified array of KeyValuePair<TKey,TValue> structures, starting at the specified index.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetEnumerator()

Retorna um enumerador que itera pelo SortedDictionary<TKey,TValue>.Returns an enumerator that iterates through the SortedDictionary<TKey,TValue>.

GetHashCode()

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

(Herdado de Object)
GetType()

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

(Herdado de Object)
MemberwiseClone()

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

(Herdado de Object)
Remove(TKey)

Remove o elemento com a chave especificada do SortedDictionary<TKey,TValue>.Removes the element with the specified key from the SortedDictionary<TKey,TValue>.

ToString()

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

(Herdado de Object)
TryGetValue(TKey, TValue)

Obtém o valor associado à chave especificada.Gets the value associated with the specified key.

Implantações explícitas de interface

ICollection.CopyTo(Array, Int32)

Copia os elementos do ICollection<T> para uma matriz, começando no índice da matriz especificada.Copies the elements of the ICollection<T> to an array, starting at the specified array index.

ICollection.IsSynchronized

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

ICollection.SyncRoot

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

ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>)

Adiciona um item ao ICollection<T>.Adds an item to the ICollection<T>.

ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)

Determina se o ICollection<T> contém uma chave e valor específicos.Determines whether the ICollection<T> contains a specific key and value.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Obtém um valor que indica se o ICollection<T> é somente leitura.Gets a value indicating whether the ICollection<T> is read-only.

ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)

Remove a primeira ocorrência do elemento especificado do ICollection<T>.Removes the first occurrence of the specified element from the ICollection<T>.

IDictionary.Add(Object, Object)

Adiciona um elemento com a chave fornecida e o valor para o IDictionary.Adds an element with the provided key and value to the IDictionary.

IDictionary.Contains(Object)

Determina se o IDictionary contém um elemento com a chave especificada.Determines whether the IDictionary contains an element with the specified key.

IDictionary.GetEnumerator()

Retorna um IDictionaryEnumerator para o IDictionary.Returns an IDictionaryEnumerator for the IDictionary.

IDictionary.IsFixedSize

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

IDictionary.IsReadOnly

Obtém um valor que indica se o IDictionary é somente leitura.Gets a value indicating whether the IDictionary is read-only.

IDictionary.Item[Object]

Obtém ou define o elemento com a chave especificada.Gets or sets the element with the specified key.

IDictionary.Keys

Obtém um ICollection que contém as chaves do IDictionary.Gets an ICollection containing the keys of the IDictionary.

IDictionary.Remove(Object)

Remove o elemento com a chave especificada do IDictionary.Removes the element with the specified key from the IDictionary.

IDictionary.Values

Obtém um ICollection que contém os valores no IDictionary.Gets an ICollection containing the values in the IDictionary.

IDictionary<TKey,TValue>.Keys

Obtém um ICollection<T> que contém as chaves do IDictionary<TKey,TValue>.Gets an ICollection<T> containing the keys of the IDictionary<TKey,TValue>.

IDictionary<TKey,TValue>.Values

Obtém um ICollection<T> que contém os valores no IDictionary<TKey,TValue>.Gets an ICollection<T> containing the values in the IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator()

Retorna um enumerador que itera por meio da coleção .Returns an enumerator that iterates through the collection.

IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator()

Retorna um enumerador que itera em uma coleção.Returns an enumerator that iterates through a collection.

IReadOnlyDictionary<TKey,TValue>.Keys

Obtém uma coleção que contém as chaves do SortedDictionary<TKey,TValue>.Gets a collection containing the keys in the SortedDictionary<TKey,TValue>.

IReadOnlyDictionary<TKey,TValue>.Values

Obtém uma coleção que contém os valores no SortedDictionary<TKey,TValue>.Gets a collection containing the values in the SortedDictionary<TKey,TValue>.

Métodos de Extensão

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey)

Tenta obter o valor associado ao key especificado no dictionary.Tries to get the value associated with the specified key in the dictionary.

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue)

Tenta obter o valor associado à chave especificada no dictionary.Tries to get the value associated with the specified key in the dictionary.

Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Tenta remover o valor com o key especificado do dictionary.Tries to remove the value with the specified key from the dictionary.

TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Tenta adicionar o key e o value especificados ao dictionary.Tries to add the specified key and value to the dictionary.

CopyToDataTable<T>(IEnumerable<T>)

Retorna um DataTable que contém cópias dos objetos DataRow, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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)

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)

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

AsQueryable(IEnumerable)

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

Ancestors<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os ancestrais de cada nó na coleção de origem.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada de elementos que contém os ancestrais de cada nó na coleção de origem.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós descendentes de todos os documentos e elementos na coleção de origem.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os elementos descendentes de cada elemento e o documento na coleção de origem.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada de elementos que contém os elementos descendentes de cada elemento e o documento na coleção de origem.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retorna uma coleção dos filhos elementos de cada elemento e o documento na coleção de origem.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Retorna uma coleção filtrada dos elementos filho de cada elemento e documento na coleção de origem.Returns a filtered collection of the child elements of every element and document in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retorna uma coleção de nós que contém todos os nós na coleção de origem, classificados em ordem segundo o documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós filhos de todos os documentos e elementos na coleção de origem.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Remove todos os nós na coleção de origem do respectivo nó pai.Removes every node in the source collection from its parent node.

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 SortedDictionary<TKey,TValue> pode dar suporte a vários leitores simultaneamente, desde que a coleção não seja modificada.A SortedDictionary<TKey,TValue> can support multiple readers concurrently, as long as the collection is not modified. Mesmo assim, a enumeração por meio de uma coleção é intrinsecamente não um procedimento de thread-safe.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Para garantir acesso thread-safe durante a enumeração, é possível bloquear a coleção durante toda a enumeração.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Para permitir que a coleção seja acessada por vários threads para leitura e gravação, você deve implementar sua própria sincronização.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Veja também