SortedDictionary<TKey,TValue> Classe

Définition

Représente une collection de paires clé/valeur triées sur la clé.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)

Paramètres de type

TKey

Type des clés dans le dictionnaire.The type of the keys in the dictionary.

TValue

Type des valeurs dans le dictionnaire.The type of the values in the dictionary.

Héritage
SortedDictionary<TKey,TValue>
Attributs
Implémente

Exemples

L’exemple de code suivant crée un SortedDictionary<TKey,TValue> vide de chaînes avec des clés de chaîne Add et utilise la méthode pour ajouter des éléments.The following code example creates an empty SortedDictionary<TKey,TValue> of strings with string keys and uses the Add method to add some elements. L’exemple montre que la Add méthode lève une ArgumentException exception lors de la tentative d’ajout d’une clé dupliquée.The example demonstrates that the Add method throws an ArgumentException when attempting to add a duplicate key.

L’exemple utilise la Item[TKey] propriété (l’indexeur dans C#) pour récupérer des valeurs, en montrant qu' KeyNotFoundException une exception est levée lorsqu’une clé demandée n’est pas présente, et montrant que la valeur associée à une clé peut être remplacée.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.

L’exemple montre comment utiliser le TryGetValue méthode comme un moyen plus efficace pour récupérer des valeurs si un programme doit souvent essayer des valeurs de clés qui ne sont pas dans le dictionnaire, il montre comment utiliser la ContainsKey méthode pour tester si une clé existe avant d’appeler le Add (méthode).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.

L’exemple montre comment énumérer les clés et les valeurs dans le dictionnaire et comment énumérer les clés et les valeurs uniquement à l' Keys aide de la Values propriété et de la propriété.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.

Enfin, l’exemple illustre la Remove méthode.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.
' 

Remarques

La SortedDictionary<TKey,TValue> classe générique est un arbre de recherche binaire avec l’extraction O (log n), où n est le nombre d’éléments dans le dictionnaire.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. À cet égard, elle est similaire à la SortedList<TKey,TValue> classe générique.In this respect, it is similar to the SortedList<TKey,TValue> generic class. Les deux classes ont des modèles objet similaires et ont toutes les deux la récupération O (log n).The two classes have similar object models, and both have O(log n) retrieval. Les différences entre les deux classes sont l’utilisation de la mémoire et la vitesse d’insertion et de suppression :Where the two classes differ is in memory use and speed of insertion and removal:

Chaque paire clé/valeur peut être récupérée en tant KeyValuePair<TKey,TValue> que structure, ou DictionaryEntry en tant que par le IDictionary biais de l’interface non générique.Each key/value pair can be retrieved as a KeyValuePair<TKey,TValue> structure, or as a DictionaryEntry through the nongeneric IDictionary interface.

Les clés doivent être immuables tant qu’elles sont utilisées en tant que clés SortedDictionary<TKey,TValue>dans le.Keys must be immutable as long as they are used as keys in the SortedDictionary<TKey,TValue>. Chaque clé dans un SortedDictionary<TKey,TValue> doit être unique.Every key in a SortedDictionary<TKey,TValue> must be unique. Une clé ne peut nullpas être, mais une valeur peut être, si le TValue type valeur est un type référence.A key cannot be null, but a value can be, if the value type TValue is a reference type.

SortedDictionary<TKey,TValue>requiert une implémentation de comparateur pour effectuer des comparaisons de clés.SortedDictionary<TKey,TValue> requires a comparer implementation to perform key comparisons. Vous pouvez spécifier une implémentation de l' IComparer<T> interface générique à l’aide d’un constructeur qui comparer accepte un paramètre. Si vous ne spécifiez pas d’implémentation, Comparer<T>.Default le GenericComparer (par défaut est utilisé.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. Si le TKey type implémente System.IComparable<T> l’interface générique, le comparateur par défaut utilise cette implémentation.If type TKey implements the System.IComparable<T> generic interface, the default comparer uses that implementation.

L' foreach instruction de la C# for eachlangue( dans C++retourne un objet du type des éléments dans la collection. For EachThe 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. Étant donné que chaque élément SortedDictionary<TKey,TValue> de est une paire clé/valeur, le type d’élément n’est pas le type de la clé ou le type de la valeur.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. Au lieu de cela, le KeyValuePair<TKey,TValue>type d’élément est.Instead, the element type is KeyValuePair<TKey,TValue>. Le code suivant illustre C#la C++syntaxe, et Visual Basic.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

L' foreach instruction est un wrapper autour de l’énumérateur, qui autorise uniquement la lecture de la collection, sans y écrire.The foreach statement is a wrapper around the enumerator, which allows only reading from the collection, not writing to it.

Constructeurs

SortedDictionary<TKey,TValue>()

Initialise une nouvelle instance de la classe SortedDictionary<TKey,TValue> vide et utilise l'implémentation de IComparer<T> par défaut pour le type de clé.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>)

Initialise une nouvelle instance de la classe SortedDictionary<TKey,TValue> vide et utilise l'implémentation de IComparer<T> spécifiée pour comparer les clés.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>)

Initialise une nouvelle instance de la classe SortedDictionary<TKey,TValue> qui contient des éléments copiés du IDictionary<TKey,TValue> spécifié et utilise l'implémentation de IComparer<T> par défaut pour le type de clé.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>)

Initialise une nouvelle instance de la classe SortedDictionary<TKey,TValue> qui contient des éléments copiés du IDictionary<TKey,TValue> spécifié et utilise l'implémentation de IComparer<T> spécifiée pour comparer les clés.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.

Propriétés

Comparer

Obtient le IComparer<T> utilisé pour ordonnancer les éléments du SortedDictionary<TKey,TValue>.Gets the IComparer<T> used to order the elements of the SortedDictionary<TKey,TValue>.

Count

Obtient le nombre de paires clé/valeur contenues dans SortedDictionary<TKey,TValue>.Gets the number of key/value pairs contained in the SortedDictionary<TKey,TValue>.

Item[TKey]

Obtient ou définit la valeur associée à la clé spécifiée.Gets or sets the value associated with the specified key.

Keys

Obtient une collection contenant les clés dans SortedDictionary<TKey,TValue>.Gets a collection containing the keys in the SortedDictionary<TKey,TValue>.

Values

Obtient une collection contenant les valeurs de SortedDictionary<TKey,TValue>.Gets a collection containing the values in the SortedDictionary<TKey,TValue>.

Méthodes

Add(TKey, TValue)

Ajoute un élément avec la clé et la valeur spécifiées dans SortedDictionary<TKey,TValue>.Adds an element with the specified key and value into the SortedDictionary<TKey,TValue>.

Clear()

Supprime tous les éléments de SortedDictionary<TKey,TValue>.Removes all elements from the SortedDictionary<TKey,TValue>.

ContainsKey(TKey)

Détermine si SortedDictionary<TKey,TValue> contient un élément avec la clé spécifiée.Determines whether the SortedDictionary<TKey,TValue> contains an element with the specified key.

ContainsValue(TValue)

Détermine si SortedDictionary<TKey,TValue> contient un élément avec la clé spécifiée.Determines whether the SortedDictionary<TKey,TValue> contains an element with the specified value.

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

Copie les éléments de SortedDictionary<TKey,TValue> dans le tableau spécifié des structures KeyValuePair<TKey,TValue> au niveau de l'index spécifié.Copies the elements of the SortedDictionary<TKey,TValue> to the specified array of KeyValuePair<TKey,TValue> structures, starting at the specified index.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetEnumerator()

Retourne un énumérateur qui itère au sein de SortedDictionary<TKey,TValue>.Returns an enumerator that iterates through the SortedDictionary<TKey,TValue>.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Remove(TKey)

Supprime l'élément avec la clé spécifiée d'SortedDictionary<TKey,TValue>.Removes the element with the specified key from the SortedDictionary<TKey,TValue>.

ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)
TryGetValue(TKey, TValue)

Obtient la valeur associée à la clé spécifiée.Gets the value associated with the specified key.

Implémentations d’interfaces explicites

ICollection.CopyTo(Array, Int32)

Copie les éléments de l'objet ICollection<T> dans un tableau, en commençant au niveau d'un index de tableau spécifié.Copies the elements of the ICollection<T> to an array, starting at the specified array index.

ICollection.IsSynchronized

Obtient une valeur indiquant si l'accès à ICollection est synchronisé (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à ICollection.Gets an object that can be used to synchronize access to the ICollection.

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

Ajoute un élément à ICollection<T>.Adds an item to the ICollection<T>.

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

Détermine si ICollection<T> contient une clé et une valeur spécifiques.Determines whether the ICollection<T> contains a specific key and value.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Obtient une valeur indiquant si ICollection<T> est en lecture seule.Gets a value indicating whether the ICollection<T> is read-only.

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

Supprime la première occurrence de l'élément spécifié dans ICollection<T>.Removes the first occurrence of the specified element from the ICollection<T>.

IDictionary.Add(Object, Object)

Ajoute un élément avec la clé et la valeur fournies à IDictionary.Adds an element with the provided key and value to the IDictionary.

IDictionary.Contains(Object)

Détermine si IDictionary contient un élément avec la clé spécifiée.Determines whether the IDictionary contains an element with the specified key.

IDictionary.GetEnumerator()

Retourne IDictionaryEnumerator pour l'objet IDictionary.Returns an IDictionaryEnumerator for the IDictionary.

IDictionary.IsFixedSize

Obtient une valeur indiquant si IDictionary est de taille fixe.Gets a value indicating whether the IDictionary has a fixed size.

IDictionary.IsReadOnly

Obtient une valeur indiquant si IDictionary est en lecture seule.Gets a value indicating whether the IDictionary is read-only.

IDictionary.Item[Object]

Obtient ou définit l'élément à l'aide de la clé spécifiée.Gets or sets the element with the specified key.

IDictionary.Keys

Obtient un ICollection contenant les clés de IDictionary.Gets an ICollection containing the keys of the IDictionary.

IDictionary.Remove(Object)

Supprime l'élément avec la clé spécifiée d'IDictionary.Removes the element with the specified key from the IDictionary.

IDictionary.Values

Obtient ICollection contenant les valeurs de IDictionary.Gets an ICollection containing the values in the IDictionary.

IDictionary<TKey,TValue>.Keys

Obtient un ICollection<T> contenant les clés de IDictionary<TKey,TValue>.Gets an ICollection<T> containing the keys of the IDictionary<TKey,TValue>.

IDictionary<TKey,TValue>.Values

Obtient ICollection<T> contenant les valeurs de IDictionary<TKey,TValue>.Gets an ICollection<T> containing the values in the IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein de la collection.Returns an enumerator that iterates through the collection.

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

Retourne un énumérateur qui itère au sein d’une collection.Returns an enumerator that iterates through a collection.

IReadOnlyDictionary<TKey,TValue>.Keys

Obtient une collection contenant les clés dans SortedDictionary<TKey,TValue>.Gets a collection containing the keys in the SortedDictionary<TKey,TValue>.

IReadOnlyDictionary<TKey,TValue>.Values

Obtient une collection contenant les valeurs de SortedDictionary<TKey,TValue>.Gets a collection containing the values in the SortedDictionary<TKey,TValue>.

Méthodes d’extension

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

Tente d’obtenir la valeur associée à la key spécifiée dans le dictionary.Tries to get the value associated with the specified key in the dictionary.

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

Tente d’obtenir la valeur associée à la clé spécifiée dans le dictionary.Tries to get the value associated with the specified key in the dictionary.

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

Tente de supprime la valeur ayant la key spécifiée du dictionary.Tries to remove the value with the specified key from the dictionary.

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

Tente d’ajouter la key spécifiée et value dans le dictionary.Tries to add the specified key and value to the dictionary.

CopyToDataTable<T>(IEnumerable<T>)

Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est 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)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est 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)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retourne une collection des nœuds descendants de chaque document et élément de la collection source.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retourne une collection des éléments enfants de chaque élément et document de la collection source.Returns a collection of the child elements of every element and document in the source collection.

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

Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source.Returns a filtered collection of the child elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retourne une collection des nœuds enfants de chaque document et élément de la collection source.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Supprime chaque nœud de la collection source de son nœud parent.Removes every node in the source collection from its parent node.

S’applique à

Cohérence de thread

Les membres statiques publics (Shared dans Visual Basic) de ce type sont thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Il n'est pas garanti que les membres d'instance soient thread-safe.Any instance members are not guaranteed to be thread safe.

Un SortedDictionary<TKey,TValue> peut prendre en charge plusieurs lecteurs simultanément, à condition que la collection ne soit pas modifiée.A SortedDictionary<TKey,TValue> can support multiple readers concurrently, as long as the collection is not modified. Même dans ce cas, l’énumération d’une collection n’est intrinsèquement pas une procédure thread-safe.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Pour garantir la sécurité des threads pendant l'énumération, vous pouvez verrouiller la collection tout au long de cette opération.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Pour permettre à plusieurs threads d’accéder en lecture et en écriture à la collection, vous devez implémenter votre propre synchronisation.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Voir aussi