Dictionary<TKey,TValue> 클래스

정의

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

generic <typename TKey, typename TValue>
public ref class Dictionary : 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
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
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
type Dictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface IDictionary
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ISerializable
    interface IDeserializationCallback
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
Public Class Dictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDeserializationCallback, IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue), ISerializable

형식 매개 변수

TKey

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

TValue

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

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

예제

참고

이 문서의 C# 예제는 Try.NET 인라인 코드 러너 및 놀이터에서 실행됩니다.The C# examples in this article run in the Try.NET inline code runner and playground. 대화형 창에서 예제를 실행하려면 실행 버튼을 선택합니다.Select the Run button to run an example in an interactive window. 코드를 실행하면 실행을 다시 선택하여 코드를 수정하고 수정된 코드를 실행할 수 있습니다.Once you execute the code, you can modify it and run the modified code by selecting Run again. 수정된 코드는 대화형 창에서 실행되거나, 컴파일이 실패하면 대화형 창에 모든 C# 컴파일러 오류 메시지가 표시됩니다.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

다음 코드 예제에서는 문자열 키를 사용 하 여 빈 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 메서드에서 중복 키를 추가 하려고 할 때 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 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.
 */
// 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.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. Dictionary<TKey,TValue> 클래스는 해시 테이블로 구현 되기 때문에 키를 사용 하 여 값을 검색 하는 것은 O (1)에 가깝습니다.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 its type TValue is a reference type.

키가 같은지 여부를 확인 하려면 Dictionary<TKey,TValue>에 같음 구현이 필요 합니다.Dictionary<TKey,TValue> requires an equality implementation to determine whether keys are equal. comparer 매개 변수를 허용 하는 생성자를 사용 하 여 IEqualityComparer<T> 제네릭 인터페이스의 구현을 지정할 수 있습니다. 구현을 지정 하지 않으면 기본 제네릭 같음 비교자 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.

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

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. 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>)

지정한 Dictionary<TKey,TValue>에서 복사된 요소를 포함하고 키 형식에 대한 기본 같음 비교자를 사용하는 IDictionary<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>)

지정한 Dictionary<TKey,TValue>에서 복사된 요소를 포함하고 지정한 IDictionary<TKey,TValue>을 사용하는 IEqualityComparer<T> 클래스의 새 인스턴스를 초기화합니다.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)

사전에서 해당 백업 스토리지를 더 이상 확장하지 않고 지정된 수의 항목까지 보유할 수 있는지 확인합니다.Ensures that the dictionary can hold up to a specified number of entries without any further expansion of its backing storage.

Equals(Object)

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

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

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

GetHashCode()

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

(다음에서 상속됨 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.

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

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

(다음에서 상속됨 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.

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

이 사전의 용량을 원래 모든 항목과 함께 초기화되었을 경우의 용량으로 설정합니다.Sets the capacity of this dictionary to what it would be if it had been originally initialized with all its entries.

TrimExcess(Int32)

해당 백업 스토리지를 더 이상 확장하지 않고 지정된 수의 항목을 보유할 수 있도록 이 사전의 용량을 설정합니다.Sets the capacity of this dictionary to hold up a specified number of entries without any further expansion of its backing storage.

TryAdd(TKey, TValue)

지정된 키와 값을 사전에 추가하려고 시도합니다.Attempts to add the specified key and value to the dictionary.

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 that indicates 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 the specified value to the ICollection<T> with the specified key.

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

ICollection<T>에 특정 키와 값이 들어 있는지 여부를 확인합니다.Determines whether the ICollection<T> contains a specific key and value.

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

지정한 배열 인덱스부터 ICollection<T>의 요소를 KeyValuePair<TKey,TValue>형식의 배열에 복사합니다.Copies the elements of the ICollection<T> to an array of type KeyValuePair<TKey,TValue>, starting at the specified array index.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

사전이 읽기 전용인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the dictionary is read-only.

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

사전에서 키와 값을 제거합니다.Removes a key and value from the dictionary.

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()

IDictionaryEnumerator 에 대한 IDictionary를 반환합니다.Returns an IDictionaryEnumerator for the IDictionary.

IDictionary.IsFixedSize

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

IDictionary.IsReadOnly

IDictionary이 읽기 전용인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates 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

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 the collection.

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

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

IReadOnlyDictionary<TKey,TValue>.Keys

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

IReadOnlyDictionary<TKey,TValue>.Values

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

확장 메서드

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

dictionary에서 지정된 key와 연결된 값을 가져오려고 시도합니다.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)

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

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

지정된 keyvaluedictionary에 추가하려고 시도합니다.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.

적용 대상

스레드 보안

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.

추가 정보