SortedList<TKey,TValue> Klasa

Definicja

Reprezentuje kolekcję par klucz/wartość, które są posortowane według klucza w oparciu o IComparer<T> skojarzoną implementację.Represents a collection of key/value pairs that are sorted by key based on the associated IComparer<T> implementation.

generic <typename TKey, typename TValue>
public ref class SortedList : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IDictionary<TKey, TValue>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyCollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyDictionary<TKey, TValue>, System::Collections::IDictionary
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class SortedList<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>, System.Collections.IDictionary
type SortedList<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface IDictionary
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
Public Class SortedList(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue)

Parametry typu

TKey

Typ kluczy w kolekcji.The type of keys in the collection.

TValue

Typ wartości w kolekcji.The type of values in the collection.

Dziedziczenie
SortedList<TKey,TValue>
Pochodne
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu tworzy puste SortedList<TKey,TValue> ciągi z kluczami ciągu i Add używa metody do dodawania niektórych elementów.The following code example creates an empty SortedList<TKey,TValue> of strings with string keys and uses the Add method to add some elements. W przykładzie pokazano, że Add Metoda ArgumentException zgłasza podczas próby dodania zduplikowanego klucza.The example demonstrates that the Add method throws an ArgumentException when attempting to add a duplicate key.

W przykładzie zastosowano Item[TKey] Właściwość (indeksator w C#) do pobierania wartości, KeyNotFoundException pokazując, że jest zgłaszany, gdy żądany klucz nie jest obecny i wskazuje, że wartość skojarzona z kluczem może zostać zastąpiona.The example uses the Item[TKey] property (the indexer in C#) to retrieve values, demonstrating that a KeyNotFoundException is thrown when a requested key is not present, and showing that the value associated with a key can be replaced.

Przykład pokazuje, jak użyć metody TryGetValue jako bardziej efektywnego sposobu pobierania wartości, jeśli program często musi wypróbować kluczowe wartości, które nie znajdują się na posortowanej liście, i pokazuje, jak użyć metody ContainsKey, aby sprawdzić, czy klucz istnieje przed wywołaniem metoda Add.The example shows how to use the TryGetValue method as a more efficient way to retrieve values if a program often must try key values that are not in the sorted list, and it shows how to use the ContainsKey method to test whether a key exists before calling the Add method.

W przykładzie pokazano, jak wyliczyć klucze i wartości na sortowanej liście oraz jak wyliczyć klucze i wartości przy użyciu Keys właściwości Values i właściwości.The example shows how to enumerate the keys and values in the sorted list and how to enumerate the keys and values alone using the Keys property and the Values property.

Na koniec przykład ilustruje Remove metodę.Finally, the example demonstrates the Remove method.

#using <System.dll>

using namespace System;
using namespace System::Collections::Generic;

public ref class Example
{
public:
    static void Main()
    {
        // Create a new sorted list of strings, with string
        // keys.
        SortedList<String^, String^>^ openWith =
            gcnew SortedList<String^, String^>();

        // Add some elements to the list. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith->Add("txt", "notepad.exe");
        openWith->Add("bmp", "paint.exe");
        openWith->Add("dib", "paint.exe");
        openWith->Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is
        // already in the list.
        try
        {
            openWith->Add("txt", "winword.exe");
        }
        catch (ArgumentException^)
        {
            Console::WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you
        // can omit its name when accessing elements.
        Console::WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console::WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the list.
        try
        {
            Console::WriteLine("For key = \"tif\", value = {0}.",
                openWith["tif"]);
        }
        catch (KeyNotFoundException^)
        {
            Console::WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the list, TryGetValue can be a more efficient
        // way to retrieve values.
        String^ value = "";
        if (openWith->TryGetValue("tif", value))
        {
            Console::WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console::WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting
        // them.
        if (!openWith->ContainsKey("ht"))
        {
            openWith->Add("ht", "hypertrm.exe");
            Console::WriteLine("Value added for key = \"ht\": {0}",
                openWith["ht"]);
        }

        // 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);
        }

        // To get the values alone, use the Values property.
        IList<String^>^ ilistValues = openWith->Values;

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

        // The Values property is an efficient way to retrieve
        // values by index.
        Console::WriteLine("\nIndexed retrieval using the Values " +
            "property: Values[2] = {0}", openWith->Values[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();
        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]);

        // Use the Remove method to remove a key/value pair.
        Console::WriteLine("\nRemove(\"doc\")");
        openWith->Remove("doc");

        if (!openWith->ContainsKey("doc"))
        {
            Console::WriteLine("Key \"doc\" is not found.");
        }
    }
};

int main()
{
    Example::Main();
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe
Key = rtf, Value = winword.exe
Key = txt, Value = notepad.exe

Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = hypertrm.exe
Value = winword.exe
Value = notepad.exe

Indexed retrieval using the Values property: Values[2] = winword.exe

Key = bmp
Key = dib
Key = doc
Key = ht
Key = rtf
Key = txt

Indexed retrieval using the Keys property: Keys[2] = doc

Remove("doc")
Key "doc" is not found.
 */
using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create a new sorted list of strings, with string
        // keys.
        SortedList<string, string> openWith = 
            new SortedList<string, string>();

        // Add some elements to the list. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the list.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the list.
        try
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", 
                openWith["tif"]);
        }
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the list, TryGetValue can be a more efficient 
        // way to retrieve values.
        string value = "";
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", 
                openWith["ht"]);
        }

        // 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);
        }

        // To get the values alone, use the Values property.
        IList<string> ilistValues = openWith.Values;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SorteList values.
        Console.WriteLine();
        foreach( string s in ilistValues )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // The Values property is an efficient way to retrieve
        // values by index.
        Console.WriteLine("\nIndexed retrieval using the Values " +
            "property: Values[2] = {0}", openWith.Values[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]);

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe
Key = rtf, Value = winword.exe
Key = txt, Value = notepad.exe

Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = hypertrm.exe
Value = winword.exe
Value = notepad.exe

Indexed retrieval using the Values property: Values[2] = winword.exe

Key = bmp
Key = dib
Key = doc
Key = ht
Key = rtf
Key = txt

Indexed retrieval using the Keys property: Keys[2] = doc

Remove("doc")
Key "doc" is not found.
 */
Imports System.Collections.Generic

Public Class Example
    
    Public Shared Sub Main() 

        ' Create a new sorted list of strings, with string 
        ' keys. 
        Dim openWith As New SortedList(Of String, String)
        
        ' Add some elements to the list. There are no 
        ' duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe")
        openWith.Add("bmp", "paint.exe")
        openWith.Add("dib", "paint.exe")
        openWith.Add("rtf", "wordpad.exe")
        
        ' The Add method throws an exception if the new key is 
        ' already in the list.
        Try
            openWith.Add("txt", "winword.exe")
        Catch 
            Console.WriteLine("An element with Key = ""txt"" already exists.")
        End Try

        ' The Item property is the default property, so you 
        ' can omit its name when accessing elements. 
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' The default Item property can be used to change the value
        ' associated with a key.
        openWith("rtf") = "winword.exe"
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' If a key does not exist, setting the default Item property
        ' for that key adds a new key/value pair.
        openWith("doc") = "winword.exe"

        ' The default Item property throws an exception if the requested
        ' key is not in the list.
        Try
            Console.WriteLine("For key = ""tif"", value = {0}.", _
                openWith("tif"))
        Catch 
            Console.WriteLine("Key = ""tif"" is not found.")
        End Try

        ' When a program often has to try keys that turn out not to
        ' be in the list, TryGetValue can be a more efficient 
        ' way to retrieve values.
        Dim value As String = ""
        If openWith.TryGetValue("tif", value) Then
            Console.WriteLine("For key = ""tif"", value = {0}.", value)
        Else
            Console.WriteLine("Key = ""tif"" is not found.")
        End If

        ' ContainsKey can be used to test keys before inserting 
        ' them.
        If Not openWith.ContainsKey("ht") Then
            openWith.Add("ht", "hypertrm.exe")
            Console.WriteLine("Value added for key = ""ht"": {0}", _
                openWith("ht"))
        End If

        ' 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

        ' To get the values alone, use the Values property.
        Dim ilistValues As IList(Of String) = openWith.Values
        
        ' The elements of the list are strongly typed with the
        ' type that was specified for the SortedList values.
        Console.WriteLine()
        For Each s As String In ilistValues
            Console.WriteLine("Value = {0}", s)
        Next s

        ' The Values property is an efficient way to retrieve
        ' values by index.
        Console.WriteLine(vbLf & "Indexed retrieval using the " & _
            "Values property: Values(2) = {0}", openWith.Values(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))

        ' Use the Remove method to remove a key/value pair.
        Console.WriteLine(vbLf + "Remove(""doc"")")
        openWith.Remove("doc")
        
        If Not openWith.ContainsKey("doc") Then
            Console.WriteLine("Key ""doc"" is not found.")
        End If

    End Sub

End Class

' This code example produces the following output:
'
'An element with Key = "txt" already exists.
'For key = "rtf", value = wordpad.exe.
'For key = "rtf", value = winword.exe.
'Key = "tif" is not found.
'Key = "tif" is not found.
'Value added for key = "ht": hypertrm.exe
'
'Key = bmp, Value = paint.exe
'Key = dib, Value = paint.exe
'Key = doc, Value = winword.exe
'Key = ht, Value = hypertrm.exe
'Key = rtf, Value = winword.exe
'Key = txt, Value = notepad.exe
'
'Value = paint.exe
'Value = paint.exe
'Value = winword.exe
'Value = hypertrm.exe
'Value = winword.exe
'Value = notepad.exe
'
'Indexed retrieval using the Values property: Values(2) = winword.exe
'
'Key = bmp
'Key = dib
'Key = doc
'Key = ht
'Key = rtf
'Key = txt
'
'Indexed retrieval using the Keys property: Keys(2) = doc
'
'Remove("doc")
'Key "doc" is not found.
' 

Uwagi

Klasa generyczna jest tablicą par klucz/wartość z pobraniem (log n), gdzie n to liczba elementów w słowniku. SortedList<TKey,TValue>The SortedList<TKey,TValue> generic class is an array of key/value pairs with O(log n) retrieval, where n is the number of elements in the dictionary. W tym celu jest podobna do SortedDictionary<TKey,TValue> klasy generycznej.In this, it is similar to the SortedDictionary<TKey,TValue> generic class. Dwie klasy mają podobne modele obiektów, a oba mają pobieranie (log n).The two classes have similar object models, and both have O(log n) retrieval. W przypadku, gdy obie klasy różnią się w zakresie wykorzystania pamięci i szybkości wstawiania i usuwania:Where the two classes differ is in memory use and speed of insertion and removal:

Kolejną różnicą między SortedDictionary<TKey,TValue> klasami i SortedList<TKey,TValue> jest SortedList<TKey,TValue> to, że program obsługuje wydajne indeksowane pobieranie kluczy Keys i wartości za pomocą kolekcji zwracanych przez właściwości i Values .Another difference between the SortedDictionary<TKey,TValue> and SortedList<TKey,TValue> classes is that SortedList<TKey,TValue> supports efficient indexed retrieval of keys and values through the collections returned by the Keys and Values properties. Nie jest konieczne ponowne generowanie list podczas uzyskiwania dostępu do właściwości, ponieważ listy są tylko otokami dla wewnętrznych tablic kluczy i wartości.It is not necessary to regenerate the lists when the properties are accessed, because the lists are just wrappers for the internal arrays of keys and values. Poniższy kod przedstawia użycie Values właściwości do indeksowanego pobierania wartości z posortowanej listy ciągów:The following code shows the use of the Values property for indexed retrieval of values from a sorted list of strings:

String^ v = mySortedList->Values[3];
string v = mySortedList.Values[3];
Dim v As String = mySortedList.Values(3)

SortedList<TKey,TValue>jest zaimplementowany jako Tablica par klucz/wartość, posortowane według klucza.SortedList<TKey,TValue> is implemented as an array of key/value pairs, sorted by the key. Każdy element można pobrać jako KeyValuePair<TKey,TValue> obiekt.Each element can be retrieved as a KeyValuePair<TKey,TValue> object.

Obiekty kluczowe muszą być niezmienne, o ile są używane jako klucze w SortedList<TKey,TValue>.Key objects must be immutable as long as they are used as keys in the SortedList<TKey,TValue>. Każdy klucz w a SortedList<TKey,TValue> musi być unikatowy.Every key in a SortedList<TKey,TValue> must be unique. Klucz nie może być null, ale wartość może być, jeśli typ wartości na liście, TValuejest typem referencyjnym.A key cannot be null, but a value can be, if the type of values in the list, TValue, is a reference type.

SortedList<TKey,TValue>wymaga implementacji porównania, aby sortować i wykonywać porównania.SortedList<TKey,TValue> requires a comparer implementation to sort and to perform comparisons. Domyślne ustawienia porównujące Comparer<T>.Default sprawdzają, czy TKey typ System.IComparable<T> klucza implementuje i używa tej implementacji, jeśli jest dostępny.The default comparer Comparer<T>.Default checks whether the key type TKey implements System.IComparable<T> and uses that implementation, if available. Jeśli nie, Comparer<T>.Default sprawdza, czy typ TKey klucza implementuje System.IComparable.If not, Comparer<T>.Default checks whether the key type TKey implements System.IComparable. Jeśli typ TKey klucza nie implementuje żadnego interfejsu, można System.Collections.Generic.IComparer<T> określić implementację w Przeciążenie comparer konstruktora, który akceptuje parametr.If the key type TKey does not implement either interface, you can specify a System.Collections.Generic.IComparer<T> implementation in a constructor overload that accepts a comparer parameter.

Pojemność a to liczba SortedList<TKey,TValue> elementów, które SortedList<TKey,TValue> mogą być przechowywane.The capacity of a SortedList<TKey,TValue> is the number of elements the SortedList<TKey,TValue> can hold. Gdy elementy są dodawane do SortedList<TKey,TValue>, pojemność jest automatycznie zwiększana zgodnie z wymaganiami przez ponowną alokację tablicy wewnętrznej.As elements are added to a SortedList<TKey,TValue>, the capacity is automatically increased as required by reallocating the internal array. Wydajność można zmniejszyć przez wywołanie TrimExcess lub przez Capacity ustawienie właściwości jawnie.The capacity can be decreased by calling TrimExcess or by setting the Capacity property explicitly. Zmniejszenie pojemności powoduje ponowną alokację pamięci i skopiowanie wszystkich elementów w SortedList<TKey,TValue>.Decreasing the capacity reallocates memory and copies all the elements in the SortedList<TKey,TValue>.

Tylko .NET Framework: W przypadku bardzo SortedList<TKey,TValue> dużych obiektów można zwiększyć maksymalną pojemność do 2 000 000 000 elementów w systemie 64-bitowym, enabled ustawiając atrybut <gcAllowVeryLargeObjects> elementu konfiguracji na true w środowisku wykonawczym..NET Framework only: For very large SortedList<TKey,TValue> 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.

foreach Instrukcja C# języka(for each C++w ,For Each w Visual Basic) zwraca obiekt typu elementów w kolekcji.The foreach statement of the C# language (for each in C++, For Each in Visual Basic) returns an object of the type of the elements in the collection. Ponieważ elementy SortedList<TKey,TValue> są par klucz/wartość, typ elementu nie jest typem klucza ani typem wartości.Since the elements of the SortedList<TKey,TValue> are key/value pairs, the element type is not the type of the key or the type of the value. Zamiast tego typ elementu to KeyValuePair<TKey,TValue>.Instead, the element type is KeyValuePair<TKey,TValue>. Przykład:For example:

for each( KeyValuePair<int, String^> kvp in mySortedList )
{
    Console::WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
foreach( KeyValuePair<int, string> kvp in mySortedList )
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
For Each kvp As KeyValuePair(Of Integer, String) In mySortedList
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value)
Next kvp

foreach Instrukcja to otoka wokół modułu wyliczającego, która umożliwia odczyt z kolekcji.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Konstruktory

SortedList<TKey,TValue>()

Inicjuje nowe wystąpienie SortedList<TKey,TValue> klasy, która jest pusta, ma domyślną pojemność początkową i używa wartości domyślnej IComparer<T>.Initializes a new instance of the SortedList<TKey,TValue> class that is empty, has the default initial capacity, and uses the default IComparer<T>.

SortedList<TKey,TValue>(IComparer<TKey>)

Inicjuje nowe wystąpienie SortedList<TKey,TValue> klasy, która jest pusta, ma domyślną pojemność początkową i używa określonego IComparer<T>.Initializes a new instance of the SortedList<TKey,TValue> class that is empty, has the default initial capacity, and uses the specified IComparer<T>.

SortedList<TKey,TValue>(IDictionary<TKey,TValue>)

Inicjuje nowe wystąpienie SortedList<TKey,TValue> klasy, która zawiera elementy skopiowane z określonego IDictionary<TKey,TValue>, ma wystarczającą pojemność, aby pomieścić liczbę skopiowanych elementów i używa wartości domyślnej IComparer<T>.Initializes a new instance of the SortedList<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue>, has sufficient capacity to accommodate the number of elements copied, and uses the default IComparer<T>.

SortedList<TKey,TValue>(IDictionary<TKey,TValue>, IComparer<TKey>)

Inicjuje nowe wystąpienie SortedList<TKey,TValue> klasy, która zawiera elementy skopiowane z określonego IDictionary<TKey,TValue>, ma wystarczającą pojemność, aby pomieścić liczbę skopiowanych elementów i używa określonego IComparer<T>.Initializes a new instance of the SortedList<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue>, has sufficient capacity to accommodate the number of elements copied, and uses the specified IComparer<T>.

SortedList<TKey,TValue>(Int32)

Inicjuje nowe wystąpienie SortedList<TKey,TValue> klasy, która jest pusta, ma określoną pojemność początkową i używa wartości domyślnej IComparer<T>.Initializes a new instance of the SortedList<TKey,TValue> class that is empty, has the specified initial capacity, and uses the default IComparer<T>.

SortedList<TKey,TValue>(Int32, IComparer<TKey>)

Inicjuje nowe wystąpienie SortedList<TKey,TValue> klasy, która jest pusta, ma określoną pojemność początkową i używa określonego IComparer<T>.Initializes a new instance of the SortedList<TKey,TValue> class that is empty, has the specified initial capacity, and uses the specified IComparer<T>.

Właściwości

Capacity

Pobiera lub ustawia liczbę elementów, które SortedList<TKey,TValue> może zawierać.Gets or sets the number of elements that the SortedList<TKey,TValue> can contain.

Comparer

IComparer<T> Pobiera dla posortowanej listy.Gets the IComparer<T> for the sorted list.

Count

Pobiera liczbę par klucz/wartość zawartych w SortedList<TKey,TValue>.Gets the number of key/value pairs contained in the SortedList<TKey,TValue>.

Item[TKey]

Pobiera lub ustawia wartość skojarzoną z określonym kluczem.Gets or sets the value associated with the specified key.

Keys

Pobiera kolekcję zawierającą klucze w SortedList<TKey,TValue>, w kolejności posortowanej.Gets a collection containing the keys in the SortedList<TKey,TValue>, in sorted order.

Values

Pobiera kolekcję zawierającą wartości SortedList<TKey,TValue>z.Gets a collection containing the values in the SortedList<TKey,TValue>.

Metody

Add(TKey, TValue)

Dodaje element z określonym kluczem i wartością do SortedList<TKey,TValue>.Adds an element with the specified key and value into the SortedList<TKey,TValue>.

Clear()

Usuwa wszystkie elementy z SortedList<TKey,TValue>.Removes all elements from the SortedList<TKey,TValue>.

ContainsKey(TKey)

Określa, SortedList<TKey,TValue> czy zawiera określony klucz.Determines whether the SortedList<TKey,TValue> contains a specific key.

ContainsValue(TValue)

Określa, SortedList<TKey,TValue> czy zawiera konkretną wartość.Determines whether the SortedList<TKey,TValue> contains a specific value.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetEnumerator()

Zwraca moduł wyliczający, który wykonuje iterację przez SortedList<TKey,TValue>.Returns an enumerator that iterates through the SortedList<TKey,TValue>.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
IndexOfKey(TKey)

Wyszukuje określony klucz i zwraca indeks (liczony od zera) w całości SortedList<TKey,TValue>.Searches for the specified key and returns the zero-based index within the entire SortedList<TKey,TValue>.

IndexOfValue(TValue)

Wyszukuje określoną wartość i zwraca indeks (liczony od zera) pierwszego wystąpienia w całości SortedList<TKey,TValue>.Searches for the specified value and returns the zero-based index of the first occurrence within the entire SortedList<TKey,TValue>.

MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
Remove(TKey)

Usuwa element z określonym kluczem z SortedList<TKey,TValue>.Removes the element with the specified key from the SortedList<TKey,TValue>.

RemoveAt(Int32)

Usuwa element w określonym indeksie SortedList<TKey,TValue>.Removes the element at the specified index of the SortedList<TKey,TValue>.

ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
TrimExcess()

Ustawia pojemność na rzeczywistą liczbę elementów w SortedList<TKey,TValue>, jeśli ta liczba jest mniejsza niż 90% bieżącej pojemności.Sets the capacity to the actual number of elements in the SortedList<TKey,TValue>, if that number is less than 90 percent of current capacity.

TryGetValue(TKey, TValue)

Pobiera wartość skojarzoną z określonym kluczem.Gets the value associated with the specified key.

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)

Kopiuje elementy ICollection Arraydo, zaczynając od określonego Array indeksu.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Pobiera wartość wskazującą, ICollection czy dostęp do elementu jest synchronizowany (bezpieczny wątkowo).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do ICollection.Gets an object that can be used to synchronize access to the ICollection.

ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>)

Dodaje parę klucz/wartość do ICollection<T>.Adds a key/value pair to the ICollection<T>.

ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)

Określa, ICollection<T> czy zawiera określony element.Determines whether the ICollection<T> contains a specific element.

ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32)

Kopiuje elementy ICollection<T> Arraydo, zaczynając od określonego Array indeksu.Copies the elements of the ICollection<T> to an Array, starting at a particular Array index.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Pobiera wartość wskazującą, czy jest ICollection<T> tylko do odczytu.Gets a value indicating whether the ICollection<T> is read-only.

ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)

Usuwa pierwsze wystąpienie określonej pary klucz/wartość z ICollection<T>.Removes the first occurrence of a specific key/value pair from the ICollection<T>.

IDictionary.Add(Object, Object)

Dodaje element z podanym kluczem i wartością do IDictionary.Adds an element with the provided key and value to the IDictionary.

IDictionary.Contains(Object)

Określa, IDictionary czy zawiera element z określonym kluczem.Determines whether the IDictionary contains an element with the specified key.

IDictionary.GetEnumerator()

IDictionaryEnumerator Zwraca wartośćIDictionarydla.Returns an IDictionaryEnumerator for the IDictionary.

IDictionary.IsFixedSize

Pobiera wartość wskazującą, IDictionary czy ma stały rozmiar.Gets a value indicating whether the IDictionary has a fixed size.

IDictionary.IsReadOnly

Pobiera wartość wskazującą, czy jest IDictionary tylko do odczytu.Gets a value indicating whether the IDictionary is read-only.

IDictionary.Item[Object]

Pobiera lub ustawia element z określonym kluczem.Gets or sets the element with the specified key.

IDictionary.Keys

Pobiera zawierający klucze IDictionary. ICollectionGets an ICollection containing the keys of the IDictionary.

IDictionary.Remove(Object)

Usuwa element z określonym kluczem z IDictionary.Removes the element with the specified key from the IDictionary.

IDictionary.Values

Pobiera zawierający wartości z IDictionary. ICollectionGets an ICollection containing the values in the IDictionary.

IDictionary<TKey,TValue>.Keys

Pobiera zawierający klucze IDictionary<TKey,TValue>. ICollection<T>Gets an ICollection<T> containing the keys of the IDictionary<TKey,TValue>.

IDictionary<TKey,TValue>.Values

Pobiera zawierający wartości z IDictionary<TKey,TValue>. ICollection<T>Gets an ICollection<T> containing the values in the IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through a collection.

IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through a collection.

IReadOnlyDictionary<TKey,TValue>.Keys

Pobiera wyliczalną kolekcję, która zawiera klucze w słowniku tylko do odczytu.Gets an enumerable collection that contains the keys in the read-only dictionary.

IReadOnlyDictionary<TKey,TValue>.Values

Pobiera wyliczalną kolekcję zawierającą wartości w słowniku tylko do odczytu.Gets an enumerable collection that contains the values in the read-only dictionary.

Metody rozszerzania

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey)

Tries to get the value associated with the specified key in the dictionary.

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue)

Tries to get the value associated with the specified key in the dictionary.

Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Tries to remove the value with the specified key from the dictionary.

TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Tries to add the specified key and value to the dictionary.

CopyToDataTable<T>(IEnumerable<T>)

DataRow T IEnumerable<T> Zwraca obiekt, DataRow który zawiera kopie obiektów, z uwzględnieniem obiektu wejściowego, w którym parametr generyczny jest. DataTableReturns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable do określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerable KonwertujeIQueryabledo.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of the child elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Zwraca kolekcję węzłów, która zawiera wszystkie węzły w kolekcji źródłowej, posortowane w kolejności dokumentu.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.Removes every node in the source collection from its parent node.

Dotyczy

Bezpieczeństwo wątkowe

Publiczne statyczne (Shared w Visual Basic) członkowie tego typu są bezpieczne wątkowo.Public static (Shared in Visual Basic) members of this type are thread safe. Wystąpienia elementów członkowskich nie dają gwarancji bezpieczeństwa wątków.Any instance members are not guaranteed to be thread safe.

SortedList<TKey,TValue> Może obsługiwać wielu czytników współbieżnie, o ile kolekcja nie jest modyfikowana.A SortedList<TKey,TValue> can support multiple readers concurrently, as long as the collection is not modified. Nawet w ten sposób Wyliczanie za pomocą kolekcji nie jest w sposób wewnętrzny bezpieczny dla wątków.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Aby zagwarantować bezpieczeństwo wątków podczas wyliczania, można zablokować kolekcję podczas całego procesu wyliczania.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Aby zezwolić wielu wątkom na dostęp do kolekcji w celu odczytu i zapisu danych, należy zaimplementować własny mechanizm synchronizacji.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Zobacz też