SortedList<TKey,TValue>.Keys Proprietà

Definizione

Spazio dei nomi:

System.Collections.Generic

Assembly:

System.Collections.dll

Source:

SortedList.cs

Ottiene una raccolta contenente le chiavi in SortedList<TKey,TValue> nell'ordine specificato.

public:
 property System::Collections::Generic::IList<TKey> ^ Keys { System::Collections::Generic::IList<TKey> ^ get(); };

public System.Collections.Generic.IList<TKey> Keys { get; }

member this.Keys : System.Collections.Generic.IList<'Key>

Public ReadOnly Property Keys As IList(Of TKey)

Valore della proprietà

IList<TKey>

Raccolta IList<T> contenente le chiavi della classe SortedList<TKey,TValue>.

Esempio

Nell'esempio di codice seguente viene illustrato come enumerare le chiavi nell'elenco ordinato usando la Keys proprietà e come enumerare le chiavi e i valori nell'elenco ordinato.

L'esempio illustra anche come usare la Keys proprietà per il recupero indicizzato efficiente delle chiavi.

Questo codice fa parte di un esempio più grande che può essere compilato ed eseguito. Vedere SortedList<TKey,TValue>.

// To get the keys alone, use the Keys property.
IList<String^>^ ilistKeys = openWith->Keys;

// The elements of the list are strongly typed with the
// type that was specified for the SortedList keys.
Console::WriteLine();
for each( String^ s in ilistKeys )
{
    Console::WriteLine("Key = {0}", s);
}

// The Keys property is an efficient way to retrieve
// keys by index.
Console::WriteLine("\nIndexed retrieval using the Keys " +
    "property: Keys[2] = {0}", openWith->Keys[2]);

// To get the keys alone, use the Keys property.
IList<string> ilistKeys = openWith.Keys;

// The elements of the list are strongly typed with the
// type that was specified for the SortedList keys.
Console.WriteLine();
foreach( string s in ilistKeys )
{
    Console.WriteLine("Key = {0}", s);
}

// The Keys property is an efficient way to retrieve
// keys by index.
Console.WriteLine("\nIndexed retrieval using the Keys " +
    "property: Keys[2] = {0}", openWith.Keys[2]);

' To get the keys alone, use the Keys property.
Dim ilistKeys As IList(Of String) = openWith.Keys

' The elements of the list are strongly typed with the
' type that was specified for the SortedList keys.
Console.WriteLine()
For Each s As String In ilistKeys 
    Console.WriteLine("Key = {0}", s)
Next s

' The Keys property is an efficient way to retrieve
' keys by index.
Console.WriteLine(vbLf & "Indexed retrieval using the " & _
    "Keys property: Keys(2) = {0}", openWith.Keys(2))

// To get the keys alone, use the Keys property.
let ilistKeys = openWith.Keys;

// The elements of the list are strongly typed with the
// type that was specified for the SortedList keys.
Console.WriteLine()
for s in ilistKeys do
    printfn $"Key = {s}"

// The Keys property is an efficient way to retrieve
// keys by index.
printf "\nIndexed retrieval using the Keys "
printfn $"property: Keys[2] = {openWith.Keys[2]}"

// When you use foreach to enumerate list elements,
// the elements are retrieved as KeyValuePair objects.
Console::WriteLine();
for each( KeyValuePair<String^, String^> kvp in openWith )
{
    Console::WriteLine("Key = {0}, Value = {1}",
        kvp.Key, kvp.Value);
}

// When you use foreach to enumerate list 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);
}

' When you use foreach to enumerate list 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

// When you use foreach to enumerate list elements,
// the elements are retrieved as KeyValuePair objects.
Console.WriteLine()
for kvp in openWith do
    printfn $"Key = {kvp.Key}, Value = {kvp.Value}"

Commenti

L'ordine delle chiavi nell'oggetto IList<T> è uguale all'ordine in SortedList<TKey,TValue>.

Il restituito IList<T> non è una copia statica; invece, il IList<T> riferimento alle chiavi nell'originale SortedList<TKey,TValue>. Pertanto, le modifiche apportate al continuano a essere riflesse nell'oggetto SortedList<TKey,TValue>IList<T>.

La raccolta restituita dalla proprietà offre un modo efficiente per recuperare le chiavi in base all'indice Keys . Non è necessario rigenerare l'elenco quando si accede alla proprietà, perché l'elenco è solo un wrapper per la matrice interna di chiavi. Il codice seguente mostra l'uso della proprietà per il Keys recupero indicizzato di chiavi da un elenco ordinato di elementi con chiavi stringa:

String^ v = mySortedList->Values[3];

string v = mySortedList.Values[3];

Dim v As String = mySortedList.Values(3)

let v = mySortedList.Values[3]

Il recupero del valore di questa proprietà è un'operazione O(1).

Vedi anche

• IList<T>
• Values