SortedList SortedList SortedList SortedList Class

Définition

Représente une collection de paires clé/valeur triées par les clés et accessible par clé et par index.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
Héritage
SortedListSortedListSortedListSortedList
Attributs
Implémente

Exemples

L’exemple de code suivant montre comment créer et initialiser un SortedList objet et comment imprimer ses clés et valeurs.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
Imports System.Collections
Imports Microsoft.VisualBasic

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:    !
 

Remarques

Un SortedList est accessible par sa clé, comme un élément dans un élément IDictionary implémentation, ou par son index, comme un élément de IList implémentation.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.

Important

Nous ne vous recommandons d’utiliser la SortedList classe pour tout nouveau développement.We don't recommend that you use the SortedList class for new development. Au lieu de cela, nous vous recommandons d’utiliser le modèle générique System.Collections.Generic.SortedList<TKey,TValue> classe.Instead, we recommend that you use the generic System.Collections.Generic.SortedList<TKey,TValue> class. Pour plus d’informations, consultez les collections Non génériques ne doit pas être utilisées sur GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Un SortedList objet conserve en interne les deux tableaux pour stocker les éléments de la liste ; autrement dit, un tableau pour les clés et un autre tableau de valeurs associées.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. Chaque élément est une paire clé/valeur qui est accessible en tant qu’un DictionaryEntry objet.Each element is a key/value pair that can be accessed as a DictionaryEntry object. Une clé ne peut pas être null, mais une valeur peut être.A key cannot be null, but a value can be.

La capacité d’un SortedList objet est le nombre d’éléments du SortedList peut contenir.The capacity of a SortedList object is the number of elements the SortedList can hold. Comme les éléments sont ajoutés à un SortedList, la capacité est automatiquement augmentée par réallocation.As elements are added to a SortedList, the capacity is automatically increased as required through reallocation. La capacité peut être diminuée en appelant TrimToSize ou en définissant le Capacity propriété explicitement.The capacity can be decreased by calling TrimToSize or by setting the Capacity property explicitly.

.NET framework : Pour très volumineux SortedList objets, vous pouvez augmenter la capacité maximale à 2 milliards des éléments sur un système 64 bits en définissant le enabled attribut de la <gcAllowVeryLargeObjects> élément de configuration true dans le environnement d’exécution..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.

Les éléments d’un SortedList objet sont triées par les clés soit selon un spécifique IComparer implémentation spécifié lorsque le SortedList est créé ou conformément au IComparable implémentation fournie par les clés elles-mêmes.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. Dans les deux cas, un SortedList n’autorise pas les clés en double.In either case, a SortedList does not allow duplicate keys.

La séquence d’index est basée sur l’ordre de tri.The index sequence is based on the sort sequence. Lorsqu’un élément est ajouté, il est inséré dans SortedList dans le tri correct ordre et l’indexation s’ajuste en conséquence.When an element is added, it is inserted into SortedList in the correct sort order, and the indexing adjusts accordingly. Lorsqu’un élément est supprimé, l’indexation s’adapte également en conséquence.When an element is removed, the indexing also adjusts accordingly. Par conséquent, l’index d’une paire clé/valeur spécifique peut changer que les éléments sont ajoutés ou supprimés à partir de la SortedList objet.Therefore, the index of a specific key/value pair might change as elements are added or removed from the SortedList object.

Opérations sur un SortedList objet ont tendance à être plus lentes que les opérations sur un Hashtable objet en raison du tri.Operations on a SortedList object tend to be slower than operations on a Hashtable object because of the sorting. Toutefois, le SortedList offre davantage de souplesse en autorisant l’accès aux valeurs via les clés associées ou les index.However, the SortedList offers more flexibility by allowing access to the values either through the associated keys or through the indexes.

Éléments de cette collection est accessible à l’aide d’un index d’entiers.Elements in this collection can be accessed using an integer index. Index de cette collection sont de base zéro.Indexes in this collection are zero-based.

Le foreach instruction du langage c# (for each en Visual Basic) retourne un objet du type des éléments dans la collection.The foreach statement of the C# language (for each in Visual Basic) returns an object of the type of the elements in the collection. Étant donné que chaque élément de la SortedList objet 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 SortedList object 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 type d’élément est DictionaryEntry.Rather, the element type is DictionaryEntry. Par exemple :For example:

for each (DictionaryEntry de in mySortedList)
{
    //...
}
foreach (DictionaryEntry de in mySortedList)
{
    //...
}
For Each de As DictionaryEntry In mySortedList
    '...
Next de

La foreach instruction est un wrapper autour de l’énumérateur, qui permet la lecture à partir n’écrit ne pas à la collection.The foreach statement is a wrapper around the enumerator, which allows only reading from, not writing to, the collection.

Constructeurs

SortedList() SortedList() SortedList() SortedList()

Initialise une nouvelle instance de la classe SortedList qui est vide, possède la capacité initiale par défaut et est triée suivant l'interface IComparable implémentée par chaque clé ajoutée à l'objet 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)

Initialise une nouvelle instance de la classe SortedList qui est vide, possède la capacité initiale par défaut et est triée suivant l'interface IComparer spécifiée.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)

Initialise une nouvelle instance de la classe SortedList qui est vide, possède la capacité initiale spécifiée et est triée suivant l'interface IComparer spécifiée.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)

Initialise une nouvelle instance de la classe SortedList qui contient des éléments copiés à partir du dictionnaire spécifié, possède la capacité initiale correspondant au nombre d'éléments copiés et est triée suivant l'interface IComparable implémentée par chaque clé.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)

Initialise une nouvelle instance de la classe SortedList qui contient des éléments copiés à partir du dictionnaire spécifié, possède la capacité initiale correspondant au nombre d'éléments copiés et est triée suivant l'interface IComparer spécifiée.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)

Initialise une nouvelle instance de la classe SortedList qui est vide, possède la capacité initiale spécifiée et est triée suivant l'interface IComparable implémentée par chaque clé ajoutée à l'objet 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.

Propriétés

Capacity Capacity Capacity Capacity

Obtient ou définit la capacité d'un objet SortedList.Gets or sets the capacity of a SortedList object.

Count Count Count Count

Obtient le nombre d'éléments contenus dans un objet SortedList.Gets the number of elements contained in a SortedList object.

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Obtient une valeur indiquant si un objet SortedList est de taille fixe.Gets a value indicating whether a SortedList object has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtient une valeur indiquant si un objet SortedList est en lecture seule.Gets a value indicating whether a SortedList object is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

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

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

Obtient ou définit la valeur associée à une clé spécifique dans un objet SortedList.Gets or sets the value associated with a specific key in a SortedList object.

Keys Keys Keys Keys

Obtient les clés d'un objet SortedList.Gets the keys in a SortedList object.

SyncRoot SyncRoot SyncRoot SyncRoot

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

Values Values Values Values

Obtient les valeurs d'un objet SortedList.Gets the values in a SortedList object.

Méthodes

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

Ajoute un élément avec la clé et la valeur spécifiées dans un objet SortedList.Adds an element with the specified key and value to a SortedList object.

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

Supprime tous les éléments d'un objet SortedList.Removes all elements from a SortedList object.

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

Crée une copie superficielle d'un objet SortedList.Creates a shallow copy of a SortedList object.

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

Détermine si un objet SortedList contient une clé spécifique.Determines whether a SortedList object contains a specific key.

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

Détermine si un objet SortedList contient une clé spécifique.Determines whether a SortedList object contains a specific key.

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

Détermine si un objet SortedList contient une valeur spécifique.Determines whether a SortedList object contains a specific value.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Copie des éléments SortedList dans un objet Array unidimensionnel, en commençant à l'index spécifié dans le tableau.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)

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

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

Obtient la valeur à l'index spécifié d'un objet SortedList.Gets the value at the specified index of a SortedList object.

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

Retourne un objet IDictionaryEnumerator qui itère a sein d'un objet SortedList.Returns an IDictionaryEnumerator object that iterates through a SortedList object.

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

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

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

Obtient la clé à l'index spécifié d'un objet SortedList.Gets the key at the specified index of a SortedList object.

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

Obtient les clés d'un objet SortedList.Gets the keys in a SortedList object.

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

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

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

Obtient les valeurs d'un objet SortedList.Gets the values in a SortedList object.

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

Retourne l'index de base zéro de la clé spécifiée dans un objet SortedList.Returns the zero-based index of the specified key in a SortedList object.

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

Retourne l'index de base zéro de la première occurrence de la valeur spécifiée dans un objet SortedList.Returns the zero-based index of the first occurrence of the specified value in a SortedList object.

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

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

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

Supprime d'un objet SortedList l'élément ayant la clé spécifiée.Removes the element with the specified key from a SortedList object.

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

Supprime l'élément à l'index spécifié d'un objet SortedList.Removes the element at the specified index of a SortedList object.

SetByIndex(Int32, Object) SetByIndex(Int32, Object) SetByIndex(Int32, Object) SetByIndex(Int32, Object)

Remplace la valeur à l'index spécifié dans un objet SortedList.Replaces the value at a specific index in a SortedList object.

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

Retourne un wrapper synchronisé (thread-safe) pour un objet SortedList.Returns a synchronized (thread-safe) wrapper for a SortedList object.

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

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

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

Affecte à la capacité le nombre réel d'éléments d'un objet SortedList.Sets the capacity to the actual number of elements in a SortedList object.

Implémentations d’interfaces explicites

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

Retourne un IEnumerator qui itère au sein de SortedList.Returns an IEnumerator that iterates through the SortedList.

Méthodes d’extension

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) 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) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) 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) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

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

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

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

S’applique à

Cohérence de thread

Statique public (Shared en 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 SortedList objet peut prendre en charge simultanément, plusieurs lecteurs, que la collection n’est pas modifiée.A SortedList object can support multiple readers concurrently, as long as the collection is not modified. Pour garantir la sécurité des threads de la SortedList, toutes les opérations doivent être effectuées via le wrapper retourné par la Synchronized(SortedList) (méthode).To guarantee the thread safety of the SortedList, all operations must be done through the wrapper returned by the Synchronized(SortedList) method.

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe.Enumerating through a collection is intrinsically not a thread-safe procedure. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours la modifier, ce qui entraîne la levée d'une exception par l'énumérateur.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Pour garantir la sécurité des threads au cours de l’énumération, vous pouvez verrouiller la collection pendant l’ensemble de l’énumération ou bien intercepter les exceptions résultant des modifications apportées par les autres 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.

Voir aussi