Dictionary<TKey,TValue> Class

정의

키와 값의 컬렉션을 나타냅니다. Represents a collection of keys and values.

[System.Runtime.InteropServices.ComVisible(false)]
public class Dictionary<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, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
형식 매개 변수
TKey

사전에 있는 키의 형식입니다. The type of the keys in the dictionary.

TValue

사전에 있는 값의 형식입니다. The type of the values in the dictionary.

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

예제

다음 코드 예제에서는 빈 Dictionary<TKey,TValue> 사용 하 여 문자열 키를 사용 하 여 문자열을 Add 일부 요소를 추가 하는 방법입니다.The following code example creates an empty Dictionary<TKey,TValue> of strings with string keys and uses the Add method to add some elements. 예제에 합니다 Add 메서드가 throw는 ArgumentException 중복 키를 추가 하려고 할 때입니다.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 dictionary, 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 dictionary 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 namespace System;
using namespace System::Collections::Generic;

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

        // Add some elements to the dictionary. 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 dictionary.
        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 dictionary.
        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 dictionary, 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 dictionary 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.
        Dictionary<String^, String^>::ValueCollection^ valueColl =
            openWith->Values;

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

        // To get the keys alone, use the Keys property.
        Dictionary<String^, String^>::KeyCollection^ keyColl =
            openWith->Keys;

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

        // 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 = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

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

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

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

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

        // Add some elements to the dictionary. 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 dictionary.
        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 dictionary.
        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 dictionary, 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 dictionary 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.
        Dictionary<string, string>.ValueCollection valueColl =
            openWith.Values;

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

        // To get the keys alone, use the Keys property.
        Dictionary<string, string>.KeyCollection keyColl =
            openWith.Keys;

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

        // 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 = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

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

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

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

Public Class Example
    
    Public Shared Sub Main() 

        ' Create a new dictionary of strings, with string keys.
        '
        Dim openWith As New Dictionary(Of String, String)
        
        ' Add some elements to the dictionary. 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 dictionary.
        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 dictionary.
        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 dictionary, 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 dictionary 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 valueColl As _
            Dictionary(Of String, String).ValueCollection = _
            openWith.Values
        
        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for dictionary values.
        Console.WriteLine()
        For Each s As String In  valueColl
            Console.WriteLine("Value = {0}", s)
        Next s

        ' To get the keys alone, use the Keys property.
        Dim keyColl As _
            Dictionary(Of String, String).KeyCollection = _
            openWith.Keys
        
        ' The elements of the KeyCollection are strongly typed
        ' with the type that was specified for dictionary keys.
        Console.WriteLine()
        For Each s As String In  keyColl
            Console.WriteLine("Key = {0}", s)
        Next s

        ' 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 = txt, Value = notepad.exe
'Key = bmp, Value = paint.exe
'Key = dib, Value = paint.exe
'Key = rtf, Value = winword.exe
'Key = doc, Value = winword.exe
'Key = ht, Value = hypertrm.exe
'
'Value = notepad.exe
'Value = paint.exe
'Value = paint.exe
'Value = winword.exe
'Value = winword.exe
'Value = hypertrm.exe
'
'Key = txt
'Key = bmp
'Key = dib
'Key = rtf
'Key = doc
'Key = ht
'
'Remove("doc")
'Key "doc" is not found.
' 

설명

Dictionary<TKey,TValue> 제네릭 클래스는 키 집합에서 값 집합에 대 한 매핑을 제공 합니다.The Dictionary<TKey,TValue> generic class provides a mapping from a set of keys to a set of values. 사전에 추가하는 각 항목은 값과 관련 키로 이루어져 있습니다.Each addition to the dictionary consists of a value and its associated key. 해당 키를 사용 하 여 값을 검색 이므로 매우 빠르며 닫기 O(1)을를 Dictionary<TKey,TValue> 클래스는 해시 테이블로 구현 됩니다.Retrieving a value by using its key is very fast, close to O(1), because the Dictionary<TKey,TValue> class is implemented as a hash table.

참고

검색의 속도 대 한 지정 된 형식의 해시 알고리즘의 품질에 따라 달라 집니다 TKey합니다.The speed of retrieval depends on the quality of the hashing algorithm of the type specified for TKey.

개체를 키로 사용으로 Dictionary<TKey,TValue>, 해당 해시 값에 영향을 주는 어떤 방식으로든 바뀌지 않아야 합니다.As long as an object is used as a key in the Dictionary<TKey,TValue>, it must not change in any way that affects its hash value. 모든 키를 Dictionary<TKey,TValue> 사전의 같음 비교자에 따라 고유 해야 합니다.Every key in a Dictionary<TKey,TValue> must be unique according to the dictionary's equality comparer. 키 일 수 없습니다 null, 형식 값 면 수 TValue 는 참조 형식입니다.A key cannot be null, but a value can be, if the value type TValue is a reference type.

Dictionary<TKey,TValue> 키가 같은지 여부를 확인 하는 같음 구현이 필요 합니다.Dictionary<TKey,TValue> requires an equality implementation to determine whether keys are equal. 구현의 지정할 수 있습니다는 IEqualityComparer<T> 허용 하는 생성자를 사용 하 여 제네릭 인터페이스를 comparer 매개 변수, 구현, 기본 제네릭 같음 비교자를 지정 하지 않으면 EqualityComparer<T>.Default 사용 됩니다.You can specify an implementation of the IEqualityComparer<T> generic interface by using a constructor that accepts a comparer parameter; if you do not specify an implementation, the default generic equality comparer EqualityComparer<T>.Default is used. 경우 형식 TKey 구현 된 System.IEquatable<T> 제네릭 인터페이스를 기본 같음 비교자를 구현 하 여 사용 합니다.If type TKey implements the System.IEquatable<T> generic interface, the default equality comparer uses that implementation.

참고

예를 들어,에서 제공 하는 대/소문자 문자열 비교자를 사용할 수 있습니다는 StringComparer 클래스는 대/소문자 구분 문자열 키를 사용 하 여 사전을 만듭니다.For example, you can use the case-insensitive string comparers provided by the StringComparer class to create dictionaries with case-insensitive string keys.

용량을 Dictionary<TKey,TValue> 요소입니다는 Dictionary<TKey,TValue> 보유할 수 있습니다.The capacity of a Dictionary<TKey,TValue> is the number of elements the Dictionary<TKey,TValue> can hold. 요소에 추가 되는 Dictionary<TKey,TValue>, 용량을 증가 시켜 자동으로 내부 배열을 다시 할당 하 여 필요에 따라 합니다.As elements are added to a Dictionary<TKey,TValue>, the capacity is automatically increased as required by reallocating the internal array.

에 대 한 대규모 Dictionary<TKey,TValue> 개체를 설정 하 여 64 비트 시스템에서 2 십억 요소에 최대 용량을 늘릴 수는 enabled 구성 요소의 특성 true 런타임 환경에서.For very large Dictionary<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 configuration element to true in the run-time environment.

열거형의 목적상 사전의 각 항목 처리는 KeyValuePair<TKey,TValue> 값과 키를 나타내는 구조입니다.For purposes of enumeration, each item in the dictionary is treated as a KeyValuePair<TKey,TValue> structure representing a value and its key. 항목이 반환 되는 순서 정의 되지 않습니다.The order in which the items are returned is undefined.

합니다 foreach C# 언어의 (for each c + +에서는 For Each Visual Basic에서) 컬렉션 요소의 형식의 개체를 반환 합니다.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. 하므로 Dictionary<TKey,TValue> 은 요소 형식, 키 및 값의 컬렉션 키의 형식 또는 값의 아닙니다.Since the Dictionary<TKey,TValue> is a collection of keys and values, the element type is not the type of the key or the type of the value. 요소 형식은 아니라는 KeyValuePair<TKey,TValue> 키 형식 및 값 형식입니다.Instead, the element type is a KeyValuePair<TKey,TValue> of the key type and the value type. 예:For example:

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

foreach 문을 원하는 열거자를 컬렉션에서 읽기만 허용 하지 쓸 래퍼입니다.The foreach statement is a wrapper around the enumerator, which allows only reading from the collection, not writing to it.

참고

키에 상속 될 수 있으므로 동작을 변경할의 절대적인 고유성을 보장할 수 없습니다를 사용 하 여 비교 하 여는 Equals 메서드.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

생성자

Dictionary<TKey,TValue>()

기본 초기 용량을 갖고 있고 키 형식에 대한 기본 같음 비교자를 사용하는 비어 있는 Dictionary<TKey,TValue> 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the Dictionary<TKey,TValue> class that is empty, has the default initial capacity, and uses the default equality comparer for the key type.

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

지정한 IDictionary<TKey,TValue>에서 복사된 요소를 포함하고 키 형식에 대한 기본 같음 비교자를 사용하는 Dictionary<TKey,TValue> 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the Dictionary<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue> and uses the default equality comparer for the key type.

Dictionary<TKey,TValue>(IDictionary<TKey,TValue>, IEqualityComparer<TKey>)

지정한 IDictionary<TKey,TValue>에서 복사된 요소를 포함하고 지정한 IEqualityComparer<T>을 사용하는 Dictionary<TKey,TValue> 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the Dictionary<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue> and uses the specified IEqualityComparer<T>.

Dictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)
Dictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)
Dictionary<TKey,TValue>(IEqualityComparer<TKey>)

기본 초기 용량을 갖고 있고 지정된 Dictionary<TKey,TValue>을 사용하는 비어 있는 IEqualityComparer<T> 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the Dictionary<TKey,TValue> class that is empty, has the default initial capacity, and uses the specified IEqualityComparer<T>.

Dictionary<TKey,TValue>(Int32)

지정된 초기 용량을 갖고 있고 키 형식에 대한 기본 같음 비교자를 사용하는 비어 있는 Dictionary<TKey,TValue> 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the Dictionary<TKey,TValue> class that is empty, has the specified initial capacity, and uses the default equality comparer for the key type.

Dictionary<TKey,TValue>(Int32, IEqualityComparer<TKey>)

지정된 초기 용량을 갖고 있고 지정된 Dictionary<TKey,TValue>을 사용하는 비어 있는 IEqualityComparer<T> 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the Dictionary<TKey,TValue> class that is empty, has the specified initial capacity, and uses the specified IEqualityComparer<T>.

Dictionary<TKey,TValue>(SerializationInfo, StreamingContext)

serialize된 데이터를 사용하여 Dictionary<TKey,TValue> 클래스의 새 인스턴스를 초기화합니다. Initializes a new instance of the Dictionary<TKey,TValue> class with serialized data.

속성

Comparer

사전에 대한 키의 일치 여부를 확인하는 데 사용되는 IEqualityComparer<T>을 가져옵니다. Gets the IEqualityComparer<T> that is used to determine equality of keys for the dictionary.

Count

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

Item[TKey]

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

Keys

Dictionary<TKey,TValue>의 키가 포함된 컬렉션을 가져옵니다. Gets a collection containing the keys in the Dictionary<TKey,TValue>.

Values

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

메서드

Add(TKey, TValue)

지정한 키와 값을 사전에 추가합니다. Adds the specified key and value to the dictionary.

Clear()

Dictionary<TKey,TValue>에서 모든 키와 값을 제거합니다. Removes all keys and values from the Dictionary<TKey,TValue>.

ContainsKey(TKey)

Dictionary<TKey,TValue>에 지정한 키가 포함되어 있는지 여부를 확인합니다. Determines whether the Dictionary<TKey,TValue> contains the specified key.

ContainsValue(TValue)

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

EnsureCapacity(Int32)
Equals(Object)

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

(Inherited from Object)
GetEnumerator()

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

GetHashCode()

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

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext)

ISerializable 인터페이스를 구현하고 Dictionary<TKey,TValue> 인스턴스를 직렬화하는 데 필요한 데이터를 반환합니다. Implements the ISerializable interface and returns the data needed to serialize the Dictionary<TKey,TValue> instance.

GetType()

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

(Inherited from Object)
MemberwiseClone()

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

(Inherited from Object)
OnDeserialization(Object)

ISerializable 인터페이스를 구현하고, deserialization이 완료되면 deserialization 이벤트를 발생시킵니다. Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(TKey)

Dictionary<TKey,TValue>에서 지정한 키가 있는 값을 제거합니다. Removes the value with the specified key from the Dictionary<TKey,TValue>.

Remove(TKey, TValue)
ToString()

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

(Inherited from Object)
TrimExcess()
TrimExcess(Int32)
TryAdd(TKey, TValue)
TryGetValue(TKey, TValue)

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

명시적 인터페이스 구현

ICollection.CopyTo(Array, Int32)

지정한 배열 인덱스부터 ICollection<T>의 요소를 배열에 복사합니다. Copies the elements of the ICollection<T> to an array, starting at the specified 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<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)
ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32)
ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly
ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)
IDictionary.Add(Object, Object)

지정한 키와 값을 사전에 추가합니다. Adds the specified key and value to the dictionary.

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 value 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
IDictionary<TKey,TValue>.Values
IEnumerable.GetEnumerator()

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

IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator()
IReadOnlyDictionary<TKey,TValue>.Keys
IReadOnlyDictionary<TKey,TValue>.Values

적용 대상

스레드 보안

Dictionary<TKey,TValue> 지원할 수 있습니다 여러 판독기 동시에 따라 컬렉션을 수정 되지 않습니다. A Dictionary<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. 열거형 쓰기 권한과 경쟁 하는 드문 경우에서 컬렉션을 열거 하는 동안 잠가야 합니다. In the rare case where an enumeration contends with write accesses, the collection must be locked during the entire enumeration. 여러 스레드에서 컬렉션에 액세스하여 읽고 쓸 수 있도록 허용하려면 사용자 지정 동기화를 구현해야 합니다. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization. 스레드로부터 안전한 대안에 대 한 참조를 ConcurrentDictionary<TKey,TValue> 클래스 또는 ImmutableDictionary<TKey,TValue> 클래스입니다. For thread-safe alternatives, see the ConcurrentDictionary<TKey,TValue> class or ImmutableDictionary<TKey,TValue> class. 공용 정적 (Shared Visual Basic의)이 형식의 멤버는 스레드로부터 안전 합니다. Public static (Shared in Visual Basic) members of this type are thread safe.

추가 정보