SortedList Classe

Definizione

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

Ereditarietà

Object

SortedList

Attributi

SerializableAttribute ComVisibleAttribute

Implementazioni

ICollection IDictionary IEnumerable ICloneable

Esempio

Nell'esempio di codice seguente viene illustrato come creare e inizializzare un SortedList oggetto e come stampare le chiavi e i valori.

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

Commenti

Un SortedList elemento può essere accessibile dalla chiave, ad esempio un elemento in qualsiasi IDictionary implementazione o dal relativo indice, come un elemento in qualsiasi IList implementazione.

Un SortedList oggetto gestisce internamente due matrici per archiviare gli elementi dell'elenco, ovvero una matrice per le chiavi e un'altra matrice per i valori associati. Ogni elemento è una coppia chiave/valore a cui è possibile accedere come DictionaryEntry oggetto. Una chiave non può essere null, ma un valore può essere.

La capacità di un SortedList oggetto è il numero di elementi che SortedList possono contenere. Poiché gli elementi vengono aggiunti a un SortedListoggetto , la capacità viene aumentata automaticamente in base alle esigenze tramite la riallocazione. La capacità può essere ridotta chiamando TrimToSize o impostando la Capacity proprietà in modo esplicito.

Solo .NET Framework: Per oggetti molto grandi SortedList , è possibile aumentare la capacità massima a 2 miliardi di elementi in un sistema a 64 bit impostando l'attributo enabled dell'elemento <gcAllowVeryLargeObjects> di configurazione su true nell'ambiente di runtime.

Gli elementi di un SortedList oggetto vengono ordinati in base alle chiavi in base a un'implementazione specifica IComparer specificata quando SortedList viene creato o in base all'implementazione IComparable fornita dalle chiavi stesse. In entrambi i casi, un oggetto SortedList non consente chiavi duplicate.

La sequenza di indice è basata sulla sequenza di ordinamento. Quando viene aggiunto un elemento, viene inserito nell'ordine di ordinamento corretto e l'indicizzazione viene modificata SortedList di conseguenza. Quando viene rimosso un elemento, l'indicizzazione viene modificata di conseguenza. Pertanto, l'indice di una coppia chiave/valore specifico può cambiare quando gli elementi vengono aggiunti o rimossi dall'oggetto SortedList .

Le operazioni su un oggetto tendono a essere più lente rispetto alle operazioni su un SortedListHashtable oggetto a causa dell'ordinamento. Tuttavia, offre SortedList maggiore flessibilità consentendo l'accesso ai valori tramite le chiavi associate o tramite gli indici.

Gli elementi di questa raccolta possono essere accessibili usando un indice intero. Gli indici in questa raccolta sono basati su zero.

L'istruzione foreach del linguaggio C# (for each in Visual Basic) restituisce un oggetto del tipo degli elementi nell'insieme. Poiché ogni elemento dell'oggetto SortedList è una coppia chiave/valore, il tipo di elemento non è il tipo della chiave o il tipo del valore. Invece, il tipo di elemento è DictionaryEntry. Ad esempio:

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

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

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

L'istruzione foreach è un wrapper intorno all'enumeratore, che consente solo la lettura da, non la scrittura in, la raccolta.

Costruttori

Proprietà

Metodi

Implementazioni dell'interfaccia esplicita

Metodi di estensione

Si applica a

Thread safety

I membri statici pubblici (Shared in Visual Basic) di questo tipo sono thread safe. Non è invece garantita la sicurezza dei membri dell'istanza.

Un SortedList oggetto può supportare più lettori simultaneamente, purché la raccolta non venga modificata. Per garantire la sicurezza del thread dell'oggetto SortedList, tutte le operazioni devono essere eseguite tramite il Synchronized(SortedList) wrapper restituito dal metodo .

L'enumerazione di una raccolta non è di per sé una procedura thread-safe. Anche se una raccolta è sincronizzata, è possibile che venga modificata da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore. Per garantire la protezione dei thread durante l'enumerazione, è possibile bloccare la raccolta per l'intera enumerazione oppure intercettare le eccezioni determinate dalle modifiche apportate da altri thread.

Vedi anche

• IComparable
• IComparer
• IDictionary
• Hashtable
• SortedList<TKey,TValue>
• Esecuzione di operazioni sulle stringhe indipendenti dalle impostazioni cultura nelle raccolte