SortedList Classe

Définition

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

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

public class SortedList : System.Collections.IDictionary

public class SortedList : ICloneable, System.Collections.IDictionary

[System.Serializable]
public class SortedList : ICloneable, System.Collections.IDictionary

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class SortedList : ICloneable, System.Collections.IDictionary

type SortedList = class
    interface ICollection
    interface IEnumerable
    interface IDictionary

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

[<System.Serializable>]
type SortedList = class
    interface IDictionary
    interface ICollection
    interface IEnumerable
    interface ICloneable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type SortedList = class
    interface IDictionary
    interface ICollection
    interface IEnumerable
    interface ICloneable

Public Class SortedList
Implements IDictionary

Public Class SortedList
Implements ICloneable, IDictionary

Héritage

Object

SortedList

Attributs

SerializableAttribute ComVisibleAttribute

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.

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

Propriétés

Méthodes

Implémentations d’interfaces explicites

Méthodes d’extension

S’applique à

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