SortedList<TKey,TValue> 클래스

정의

연관된 IComparer<T> 구현을 기반으로 키에 따라 정렬된 키/값 쌍의 컬렉션을 나타냅니다.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)

형식 매개 변수

TKey

컬렉션에 있는 키의 형식입니다.The type of keys in the collection.

TValue

컬렉션에 있는 값의 형식입니다.The type of values in the collection.

상속
SortedList<TKey,TValue>
파생
특성
구현

예제

다음 코드 예제에서는 문자열 키를 사용 하 여 빈 SortedList<TKey,TValue> 문자열을 만들고 Add 메서드를 사용 하 여 일부 요소를 추가 합니다.The following code example creates an empty SortedList<TKey,TValue> of strings with string keys and uses the Add method to add some elements. 이 예제에서는 Add 메서드에서 중복 키를 추가 하려고 할 때 ArgumentException를 throw 하는 방법을 보여 줍니다.The example demonstrates that the Add method throws an ArgumentException when attempting to add a duplicate key.

이 예제에서는 Item[TKey] 속성 (의 C#인덱서)을 사용 하 여 값을 검색 하 고, 요청 된 키가 없을 때 KeyNotFoundException throw 되 고, 키와 연결 된 값을 바꿀 수 있음을 보여 줍니다.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.

사용 하는 방법을 보여 주는 예제는는 TryGetValue 메서드 값을 검색 하는 프로그램 자주 사용 해야 정렬된 된 목록에 없는 키 값을 사용 하는 방법을 보여 줍니다 하는 경우는 더욱 효율적인 방법으로는 ContainsKey 메서드는 를호출하기전에키가있는지여부를테스트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.

이 예제에서는 정렬 된 목록의 키 및 값을 열거 하는 방법과 Keys 속성 및 Values 속성을 사용 하 여 키 및 값만 열거 하는 방법을 보여 줍니다.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.

마지막으로이 예제에서는 Remove 메서드를 보여 줍니다.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.
' 

설명

SortedList<TKey,TValue> 제네릭 클래스는 O (로그 n) 검색을 사용 하는 키/값 쌍의 배열입니다. 여기서 n은 사전에 있는 요소 수입니다.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. 이는 SortedDictionary<TKey,TValue> 제네릭 클래스와 비슷합니다.In this, it is similar to the SortedDictionary<TKey,TValue> generic class. 두 클래스는 비슷한 개체 모델을 가지 며 둘 다 O (로그 n) 검색을 포함 합니다.The two classes have similar object models, and both have O(log n) retrieval. 메모리 사용 및 속도의 삽입 및 제거에는 두 클래스의 다른 위치:Where the two classes differ is in memory use and speed of insertion and removal:

SortedDictionary<TKey,TValue>SortedList<TKey,TValue> 클래스의 또 다른 차이점은 SortedList<TKey,TValue> KeysValues 속성에서 반환 된 컬렉션을 통해 키와 값의 효율적인 인덱싱된 검색을 지원 한다는 것입니다.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. 목록에서 키와 값의 내부 배열에 대 한 래퍼인만 있으므로 속성에 액세스 하는 경우 목록을 다시 생성할 필요는 없습니다.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. 다음 코드에서는 정렬 된 문자열 목록에서 값의 인덱싱된 검색에 Values 속성을 사용 하는 방법을 보여 줍니다.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>는 키를 기준으로 정렬 된 키/값 쌍의 배열로 구현 됩니다.SortedList<TKey,TValue> is implemented as an array of key/value pairs, sorted by the key. 각 요소는 KeyValuePair<TKey,TValue> 개체로 검색할 수 있습니다.Each element can be retrieved as a KeyValuePair<TKey,TValue> object.

키 개체를 SortedList<TKey,TValue>키로 사용 하는 경우에는 변경할 수 없어야 합니다.Key objects must be immutable as long as they are used as keys in the SortedList<TKey,TValue>. SortedList<TKey,TValue>의 모든 키는 고유 해야 합니다.Every key in a SortedList<TKey,TValue> must be unique. 키를 null수는 없지만, TValue목록에 있는 값의 형식이 참조 형식인 경우 값은 일 수 있습니다.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>를 정렬 하 고 비교를 수행 하려면 비교자 구현이 필요 합니다.SortedList<TKey,TValue> requires a comparer implementation to sort and to perform comparisons. 기본 비교자 Comparer<T>.DefaultTKey 형식이 System.IComparable<T>를 구현 하는지 여부를 확인 하 고 사용 가능한 경우 해당 구현을 사용 합니다.The default comparer Comparer<T>.Default checks whether the key type TKey implements System.IComparable<T> and uses that implementation, if available. 그렇지 않으면 Comparer<T>.Default TKey 키 형식이 System.IComparable를 구현 하는지 여부를 확인 합니다.If not, Comparer<T>.Default checks whether the key type TKey implements System.IComparable. TKey 키 형식이 두 인터페이스를 모두 구현 하지 않는 경우 comparer 매개 변수를 허용 하는 생성자 오버 로드에서 System.Collections.Generic.IComparer<T> 구현을 지정할 수 있습니다.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.

SortedList<TKey,TValue> 용량은 SortedList<TKey,TValue>에서 보유할 수 있는 요소의 수입니다.The capacity of a SortedList<TKey,TValue> is the number of elements the SortedList<TKey,TValue> can hold. 요소가 SortedList<TKey,TValue>에 추가 되 면 내부 배열을 다시 할당 하 여 필요에 따라 용량이 자동으로 증가 합니다.As elements are added to a SortedList<TKey,TValue>, the capacity is automatically increased as required by reallocating the internal array. TrimExcess를 호출 하거나 Capacity 속성을 명시적으로 설정 하 여 용량을 줄일 수 있습니다.The capacity can be decreased by calling TrimExcess or by setting the Capacity property explicitly. 용량을 줄이면 메모리를 다시 할당 하 고 SortedList<TKey,TValue>모든 요소를 복사 합니다.Decreasing the capacity reallocates memory and copies all the elements in the SortedList<TKey,TValue>.

.NET Framework에만 해당: 매우 큰 SortedList<TKey,TValue> 개체의 경우 <gcAllowVeryLargeObjects> 구성 요소의 enabled 특성을 런타임 환경에서 true로 설정 하 여 64 비트 시스템에서 최대 용량을 20억 요소로 늘릴 수 있습니다..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.

C# 언어의 foreach 문 (의 C++for each, Visual Basic의 For Each)은 컬렉션의 요소 형식에 대 한 개체를 반환 합니다.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. SortedList<TKey,TValue> 요소는 키/값 쌍 이므로 요소 형식은 키의 형식이 나 값의 형식이 아닙니다.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. 대신 요소 형식이 KeyValuePair<TKey,TValue>됩니다.Instead, the element type is KeyValuePair<TKey,TValue>. 예를 들면 다음과 같습니다.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 문은 컬렉션에 쓰지 않고 읽을 수 있는 열거자에 대 한 래퍼입니다.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

생성자

SortedList<TKey,TValue>()

기본 초기 용량을 갖고 있고 기본 SortedList<TKey,TValue>을 사용하는 비어 있는 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>)

기본 초기 용량을 갖고 있고 지정된 SortedList<TKey,TValue>을 사용하는 비어 있는 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>)

지정된 SortedList<TKey,TValue>에서 복사된 요소가 포함되어 있고, 복사된 요소의 수를 수용할 수 있는 충분한 용량을 가지며, 기본 IDictionary<TKey,TValue>을 사용하는 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>)

지정된 SortedList<TKey,TValue>에서 복사된 요소가 포함되어 있고, 복사된 요소의 수를 수용할 수 있는 충분한 용량을 가지며, 지정된 IDictionary<TKey,TValue>을 사용하는 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)

지정된 초기 용량을 갖고 있고 기본 SortedList<TKey,TValue>을 사용하는 비어 있는 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>)

지정된 초기 용량을 갖고 있고 지정된 SortedList<TKey,TValue>을 사용하는 비어 있는 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>.

속성

Capacity

SortedList<TKey,TValue>에 포함될 수 있는 요소의 수를 가져오거나 설정합니다.Gets or sets the number of elements that the SortedList<TKey,TValue> can contain.

Comparer

정렬된 목록에 대한 IComparer<T>을 가져옵니다.Gets the IComparer<T> for the sorted list.

Count

SortedList<TKey,TValue>에 포함된 키/값 쌍의 수를 가져옵니다.Gets the number of key/value pairs contained in the SortedList<TKey,TValue>.

Item[TKey]

지정된 키와 연결된 값을 가져오거나 설정합니다.Gets or sets the value associated with the specified key.

Keys

SortedList<TKey,TValue>에 있는 키가 들어있는 컬렉션을 정렬 순서대로 가져옵니다.Gets a collection containing the keys in the SortedList<TKey,TValue>, in sorted order.

Values

SortedList<TKey,TValue>의 값을 포함하는 컬렉션을 가져옵니다.Gets a collection containing the values in the SortedList<TKey,TValue>.

메서드

Add(TKey, TValue)

지정한 키와 값을 가지는 요소를 SortedList<TKey,TValue>에 추가합니다.Adds an element with the specified key and value into the SortedList<TKey,TValue>.

Clear()

SortedList<TKey,TValue>에서 요소를 모두 제거합니다.Removes all elements from the SortedList<TKey,TValue>.

ContainsKey(TKey)

SortedList<TKey,TValue>에 특정 키가 들어 있는지 여부를 확인합니다.Determines whether the SortedList<TKey,TValue> contains a specific key.

ContainsValue(TValue)

SortedList<TKey,TValue>에 특정 값이 들어 있는지 여부를 확인합니다.Determines whether the SortedList<TKey,TValue> contains a specific value.

Equals(Object)

지정한 개체가 현재 개체와 같은지를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetEnumerator()

SortedList<TKey,TValue>을 통해 반복하는 열거자를 반환합니다.Returns an enumerator that iterates through the SortedList<TKey,TValue>.

GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
IndexOfKey(TKey)

지정한 키를 검색하고 전체 SortedList<TKey,TValue>에서 인덱스(0부터 시작)를 반환합니다.Searches for the specified key and returns the zero-based index within the entire SortedList<TKey,TValue>.

IndexOfValue(TValue)

지정한 값을 검색하고 전체 SortedList<TKey,TValue>에서 이 값이 맨 처음 발견되는 인덱스(0부터 시작)를 반환합니다.Searches for the specified value and returns the zero-based index of the first occurrence within the entire SortedList<TKey,TValue>.

MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
Remove(TKey)

SortedList<TKey,TValue>에서 키가 지정된 요소를 제거합니다.Removes the element with the specified key from the SortedList<TKey,TValue>.

RemoveAt(Int32)

SortedList<TKey,TValue>의 지정된 인덱스에 있는 요소를 제거합니다.Removes the element at the specified index of the SortedList<TKey,TValue>.

ToString()

현재 개체를 나타내는 string을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)
TrimExcess()

SortedList<TKey,TValue>의 실제 요소 수가 현재 용량의 90% 미만인 경우 용량을 이 값으로 설정합니다.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)

지정된 키와 연결된 값을 가져옵니다.Gets the value associated with the specified key.

명시적 인터페이스 구현

ICollection.CopyTo(Array, Int32)

특정 ICollection 인덱스부터 시작하여 Array의 요소를 Array에 복사합니다.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

ICollection에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지를 나타내는 값을 가져옵니다.Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

ICollection에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다.Gets an object that can be used to synchronize access to the ICollection.

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

ICollection<T>에 키/값 쌍을 추가합니다.Adds a key/value pair to the ICollection<T>.

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

ICollection<T>에 특정 요소가 들어 있는지 여부를 확인합니다.Determines whether the ICollection<T> contains a specific element.

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

특정 ICollection<T> 인덱스부터 시작하여 Array의 요소를 Array에 복사합니다.Copies the elements of the ICollection<T> to an Array, starting at a particular Array index.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

ICollection<T>이 읽기 전용인지를 표시하는 값을 가져옵니다.Gets a value indicating whether the ICollection<T> is read-only.

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

ICollection<T>에서 맨 처음 발견되는 특정 키/값 쌍을 제거합니다.Removes the first occurrence of a specific key/value pair from the ICollection<T>.

IDictionary.Add(Object, Object)

제공된 키와 값을 가진 요소를 IDictionary에 추가합니다.Adds an element with the provided key and value to the IDictionary.

IDictionary.Contains(Object)

지정된 키를 갖는 요소가 IDictionary에 들어 있는지 여부를 결정합니다.Determines whether the IDictionary contains an element with the specified key.

IDictionary.GetEnumerator()

IDictionaryEnumeratorIDictionary을 반환합니다.Returns an IDictionaryEnumerator for the IDictionary.

IDictionary.IsFixedSize

IDictionary의 크기가 고정되어 있는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the IDictionary has a fixed size.

IDictionary.IsReadOnly

IDictionary이 읽기 전용인지를 표시하는 값을 가져옵니다.Gets a value indicating whether the IDictionary is read-only.

IDictionary.Item[Object]

지정한 키를 가진 요소를 가져오거나 설정합니다.Gets or sets the element with the specified key.

IDictionary.Keys

ICollection의 키를 포함하는 IDictionary을 가져옵니다.Gets an ICollection containing the keys of the IDictionary.

IDictionary.Remove(Object)

IDictionary에서 키가 지정된 요소를 제거합니다.Removes the element with the specified key from the IDictionary.

IDictionary.Values

ICollection의 값이 들어 있는 IDictionary을 가져옵니다.Gets an ICollection containing the values in the IDictionary.

IDictionary<TKey,TValue>.Keys

ICollection<T>의 키를 포함하는 IDictionary<TKey,TValue>을 가져옵니다.Gets an ICollection<T> containing the keys of the IDictionary<TKey,TValue>.

IDictionary<TKey,TValue>.Values

ICollection<T>의 값이 들어 있는 IDictionary<TKey,TValue>을 가져옵니다.Gets an ICollection<T> containing the values in the IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator()

컬렉션 전체를 반복하는 열거자를 반환합니다.Returns an enumerator that iterates through a collection.

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

컬렉션 전체를 반복하는 열거자를 반환합니다.Returns an enumerator that iterates through a collection.

IReadOnlyDictionary<TKey,TValue>.Keys

읽기 전용 사전의 키를 포함하는 열거 가능한 컬렉션을 가져옵니다.Gets an enumerable collection that contains the keys in the read-only dictionary.

IReadOnlyDictionary<TKey,TValue>.Values

읽기 전용 사전의 값을 포함하는 열거 가능한 컬렉션을 가져옵니다.Gets an enumerable collection that contains the values in the read-only dictionary.

확장 메서드

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

key에서 지정된 dictionary과(와) 연결된 값을 가져오려고 시도합니다.Tries to get the value associated with the specified key in the dictionary.

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

지정된 키에 연결된 값을 dictionary에서 가져오려고 시도합니다.Tries to get the value associated with the specified key in the dictionary.

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

key에서 지정된 dictionary을(를) 사용하여 값 제거하려고 시도합니다.Tries to remove the value with the specified key from the dictionary.

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

지정된 keyvalue을(를) dictionary에 추가하려고 시도합니다.Tries to add the specified key and value to the dictionary.

CopyToDataTable<T>(IEnumerable<T>)

제네릭 매개 변수 TDataTable인 지정된 입력 DataRow 개체를 사용하여 IEnumerable<T> 개체의 복사본이 들어 있는 DataRow을 반환합니다.Returns 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)

제네릭 매개 변수 TDataRow인 지정된 입력 DataTable 개체를 사용하여 IEnumerable<T> 개체를 지정된 DataRow에 복사합니다.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)

제네릭 매개 변수 TDataRow인 지정된 입력 DataTable 개체를 사용하여 IEnumerable<T> 개체를 지정된 DataRow에 복사합니다.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

IEnumerable의 요소를 지정된 형식으로 캐스팅합니다.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

지정된 형식에 따라 IEnumerable의 요소를 필터링합니다.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

쿼리를 병렬화할 수 있도록 합니다.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerableIQueryable로 변환합니다.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

소스 컬렉션에 있는 모든 노드의 상위 항목을 포함 하는 요소의 컬렉션을 반환 합니다.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

소스 컬렉션에 있는 모든 노드의 상위 항목이 들어 있는 필터링 된 요소 컬렉션을 반환 합니다.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. 일치하는 XName이 있는 요소만 컬렉션에 포함됩니다.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

소스 컬렉션에 있는 모든 문서 및 요소의 하위 노드의 컬렉션을 반환합니다.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

소스 컬렉션에 있는 모든 요소 및 문서의 하위 요소가 들어 있는 요소 컬렉션을 반환합니다.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

소스 컬렉션에 있는 모든 요소 및 문서의 하위 요소가 들어 있는 필터링된 요소 컬렉션을 반환합니다.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. 일치하는 XName이 있는 요소만 컬렉션에 포함됩니다.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

소스 컬렉션에 있는 자식 컬렉션의 모든 요소 및 문서의 요소를 반환합니다.Returns a collection of the child elements of every element and document in the source collection.

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

소스 컬렉션의 필터링 된 자식 컬렉션을 모든 요소 및 문서의 요소를 반환합니다.Returns a filtered collection of the child elements of every element and document in the source collection. 일치하는 XName이 있는 요소만 컬렉션에 포함됩니다.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

모든 노드가 문서 순으로 정렬 된 소스 컬렉션에 포함 된 노드의 컬렉션을 반환 합니다.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

소스 컬렉션에 있는 자식 컬렉션의 모든 문서 및 요소의 노드를 반환합니다.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

부모 노드에서 소스 컬렉션에 있는 모든 노드를 제거합니다.Removes every node in the source collection from its parent node.

적용 대상

스레드 보안

공용 정적 (Shared Visual Basic의)이 형식의 멤버는 스레드로부터 안전 합니다.Public static (Shared in Visual Basic) members of this type are thread safe. 인스턴스 멤버는 스레드로부터의 안전이 보장되지 않습니다.Any instance members are not guaranteed to be thread safe.

SortedList<TKey,TValue> 지원할 수 있습니다 여러 판독기 동시에 따라 컬렉션을 수정 되지 않습니다.A SortedList<TKey,TValue> can support multiple readers concurrently, as long as the collection is not modified. 이 경우에 컬렉션을 열거 본질적으로 스레드로부터 안전한 프로시저가 아닙니다.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. 열거 동안 스레드 보안을 보장하려면 전체 열거 동안 컬렉션을 잠그면 됩니다.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. 여러 스레드에서 컬렉션에 액세스하여 읽고 쓸 수 있도록 허용하려면 사용자 지정 동기화를 구현해야 합니다.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

추가 정보