SortedList Classe

Définition

Espace de noms:

System.Collections

Assembly:

System.Collections.NonGeneric.dll

Source:

SortedList.cs

Représente une collection de paires clé/valeur triées par les clés et accessible par clé et par index.

public ref class SortedList : ICloneable, System::Collections::IDictionary

public class SortedList : ICloneable, System.Collections.IDictionary

type SortedList = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable

Public Class SortedList
Implements ICloneable, IDictionary

Héritage

Object

SortedList

Implémente

ICollection IDictionary IEnumerable ICloneable

Exemples

L’exemple de code suivant montre comment créer et initialiser un SortedList objet et comment imprimer ses clés et ses valeurs.

#using <system.dll>

using namespace System;
using namespace System::Collections;
public ref class SamplesSortedList
{
public:
   static void PrintKeysAndValues( SortedList^ myList )
   {
      Console::WriteLine( "\t-KEY-\t-VALUE-" );
      for ( int i = 0; i < myList->Count; i++ )
      {
         Console::WriteLine( "\t{0}:\t{1}", myList->GetKey( i ), myList->GetByIndex( i ) );

      }
      Console::WriteLine();
   }

};

int main()
{

   // Creates and initializes a new SortedList.
   SortedList^ mySL = gcnew SortedList;
   mySL->Add( "Third", "!" );
   mySL->Add( "Second", "World" );
   mySL->Add( "First", "Hello" );

   // Displays the properties and values of the SortedList.
   Console::WriteLine( "mySL" );
   Console::WriteLine( "  Count:    {0}", mySL->Count );
   Console::WriteLine( "  Capacity: {0}", mySL->Capacity );
   Console::WriteLine( "  Keys and Values:" );
   SamplesSortedList::PrintKeysAndValues( mySL );
}

/*
This code produces the following output.

mySL
Count:    3
Capacity: 16
Keys and Values:
-KEY-    -VALUE-
First:    Hello
Second:    World
Third:    !
*/

using System;
using System.Collections;

public class SamplesSortedList2
{
    public static void Main()
    {
        // Creates and initializes a new SortedList.
        SortedList mySL = new SortedList();
        mySL.Add("Third", "!");
        mySL.Add("Second", "World");
        mySL.Add("First", "Hello");

        // Displays the properties and values of the SortedList.
        Console.WriteLine("mySL");
        Console.WriteLine("  Count:    {0}", mySL.Count);
        Console.WriteLine("  Capacity: {0}", mySL.Capacity);
        Console.WriteLine("  Keys and Values:");
        PrintKeysAndValues(mySL);
    }

    public static void PrintKeysAndValues(SortedList myList)
    {
        Console.WriteLine("\t-KEY-\t-VALUE-");
        for (int i = 0; i < myList.Count; i++)
        {
            Console.WriteLine("\t{0}:\t{1}", myList.GetKey(i), myList.GetByIndex(i));
        }
        Console.WriteLine();
    }
}
/*
This code produces the following output.

mySL
  Count:    3
  Capacity: 16
  Keys and Values:
    -KEY-    -VALUE-
    First:    Hello
    Second:    World
    Third:    !
*/

Imports System.Collections

Public Class SamplesSortedList    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new SortedList.
        Dim mySL As New SortedList()
        mySL.Add("Third", "!")
        mySL.Add("Second", "World")
        mySL.Add("First", "Hello")
        
        ' Displays the properties and values of the SortedList.
        Console.WriteLine("mySL")
        Console.WriteLine("  Count:    {0}", mySL.Count)
        Console.WriteLine("  Capacity: {0}", mySL.Capacity)
        Console.WriteLine("  Keys and Values:")
        PrintKeysAndValues(mySL)
    End Sub
    
    Public Shared Sub PrintKeysAndValues(myList As SortedList)
        Console.WriteLine(ControlChars.Tab & "-KEY-" & ControlChars.Tab & _
           "-VALUE-")
        Dim i As Integer
        For i = 0 To myList.Count - 1
            Console.WriteLine(ControlChars.Tab & "{0}:" & ControlChars.Tab & _
               "{1}", myList.GetKey(i), myList.GetByIndex(i))
        Next i
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' mySL
'   Count:    3
'   Capacity: 16
'   Keys and Values:
'     -KEY-     -VALUE-
'     First:    Hello
'     Second:   World
'     Third:    !

Remarques

Un SortedList élément est accessible par sa clé, comme un élément dans n’importe quelle IDictionary implémentation, ou par son index, comme un élément dans n’importe quelle IList implémentation.

Important

Nous vous déconseillons d’utiliser la classe pour le SortedList nouveau développement. Au lieu de cela, nous vous recommandons d’utiliser la classe générique System.Collections.Generic.SortedList<TKey,TValue> . Pour plus d’informations, consultez Collections non génériques ne doivent pas être utilisées sur GitHub.

Un SortedList objet gère en interne deux tableaux pour stocker les éléments de la liste , c’est-à-dire un tableau pour les clés et un autre tableau pour les valeurs associées. Chaque élément est une paire clé/valeur accessible en tant qu’objet DictionaryEntry . Une clé ne peut pas être null, mais une valeur peut l’être.

La capacité d’un SortedList objet est le nombre d’éléments que le SortedList peut contenir. À mesure que des éléments sont ajoutés à un SortedList, la capacité est automatiquement augmentée en fonction des besoins par le biais de la réaffectation. La capacité peut être réduite en appelant TrimToSize ou en définissant explicitement la Capacity propriété.

.NET Framework uniquement : Pour les objets très volumineux SortedList , vous pouvez augmenter la capacité maximale à 2 milliards d’éléments sur un système 64 bits en définissant l’attribut enabled de l’élément <gcAllowVeryLargeObjects> de configuration sur dans l’environnement d’exécution true .

Les éléments d’un SortedList objet sont triés par les clés en fonction d’une implémentation spécifique IComparer spécifiée lors de la SortedList création de ou en fonction de l’implémentation IComparable fournie par les clés elles-mêmes. Dans les deux cas, un SortedList n’autorise pas les clés en double.

La séquence d’index est basée sur la séquence de tri. Lorsqu’un élément est ajouté, il est inséré SortedList dans dans l’ordre de tri correct et l’indexation s’ajuste en conséquence. Lorsqu’un élément est supprimé, l’indexation s’ajuste également en conséquence. Par conséquent, l’index d’une paire clé/valeur spécifique peut changer à mesure que des éléments sont ajoutés ou supprimés de l’objet SortedList .

Les opérations sur un SortedList objet ont tendance à être plus lentes que les opérations sur un Hashtable objet en raison du tri. Toutefois, le SortedList offre plus de flexibilité en autorisant l’accès aux valeurs par le biais des clés associées ou par le biais des index.

Les éléments de cette collection sont accessibles à l’aide d’un index entier. Les index de cette collection sont de base zéro.

L’instruction foreach du langage C# (for each en Visual Basic) retourne un objet du type des éléments de la collection. Étant donné que chaque élément de l’objet SortedList est une paire clé/valeur, le type d’élément n’est pas le type de la clé ou le type de la valeur. Au lieu de cela, le type d’élément est DictionaryEntry. Exemple :

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

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

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

L’instruction foreach est un wrapper autour de l’énumérateur, qui autorise uniquement la lecture à partir de la collection, et non l’écriture dans.

Constructeurs

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.
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.
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.
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é.
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.
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.

Propriétés

Capacity	Obtient ou définit la capacité d'un objet SortedList.
Count	Obtient le nombre d'éléments contenus dans un objet SortedList.
IsFixedSize	Obtient une valeur indiquant si un objet SortedList est de taille fixe.
IsReadOnly	Obtient une valeur indiquant si un objet SortedList est en lecture seule.
IsSynchronized	Obtient une valeur indiquant si l'accès à un objet SortedList est synchronisé (thread-safe).
Item[Object]	Obtient ou définit la valeur associée à une clé spécifique dans un objet SortedList.
Keys	Obtient les clés d'un objet SortedList.
SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l'accès à un objet SortedList.
Values	Obtient les valeurs d'un objet SortedList.

Méthodes

Add(Object, Object)	Ajoute un élément avec la clé et la valeur spécifiées dans un objet SortedList.
Clear()	Supprime tous les éléments d'un objet SortedList.
Clone()	Crée une copie superficielle d'un objet SortedList.
Contains(Object)	Détermine si un objet SortedList contient une clé spécifique.
ContainsKey(Object)	Détermine si un objet SortedList contient une clé spécifique.
ContainsValue(Object)	Détermine si un objet SortedList contient une valeur spécifique.
CopyTo(Array, Int32)	Copie des éléments SortedList dans un objet Array unidimensionnel, en commençant à l'index spécifié dans le tableau.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetByIndex(Int32)	Obtient la valeur à l'index spécifié d'un objet SortedList.
GetEnumerator()	Retourne un objet IDictionaryEnumerator qui itère a sein d'un objet SortedList.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetKey(Int32)	Obtient la clé à l'index spécifié d'un objet SortedList.
GetKeyList()	Obtient les clés d'un objet SortedList.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
GetValueList()	Obtient les valeurs d'un objet SortedList.
IndexOfKey(Object)	Retourne l'index de base zéro de la clé spécifiée dans un objet SortedList.
IndexOfValue(Object)	Retourne l'index de base zéro de la première occurrence de la valeur spécifiée dans un objet SortedList.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Remove(Object)	Supprime d'un objet SortedList l'élément ayant la clé spécifiée.
RemoveAt(Int32)	Supprime l'élément à l'index spécifié d'un objet SortedList.
SetByIndex(Int32, Object)	Remplace la valeur à l'index spécifié dans un objet SortedList.
Synchronized(SortedList)	Retourne un wrapper synchronisé (thread-safe) pour un objet SortedList.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
TrimToSize()	Affecte à la capacité le nombre réel d'éléments d'un objet SortedList.

Implémentations d’interfaces explicites

IEnumerable.GetEnumerator()

Retourne un IEnumerator qui itère au sein de SortedList.

Méthodes d’extension

Cast<TResult>(IEnumerable)	Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d'une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

Cohérence de thread

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread safe. Tous les membres de l'instance ne sont pas garantis comme étant thread-safe.

Un SortedList objet peut prendre en charge plusieurs lecteurs simultanément, tant que la collection n’est pas modifiée. Pour garantir la sécurité du thread de , SortedListtoutes les opérations doivent être effectuées via le wrapper retourné par la Synchronized(SortedList) méthode .

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. 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. 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.

Voir aussi

• IComparable
• IComparer
• IDictionary
• Hashtable
• SortedList<TKey,TValue>
• Exécution d’opérations de chaîne Culture-Insensitive dans des collections