Hashtable 클래스

정의

키의 해시 코드에 따라 구성된 키/값 쌍의 컬렉션을 나타냅니다.Represents a collection of key/value pairs that are organized based on the hash code of the key.

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type Hashtable = class
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable
상속
Hashtable
파생
특성
구현

예제

다음 예제에서는 Hashtable에 대 한 다양 한 기능을 만들고 초기화 하 고 수행 하는 방법과 해당 키 및 값을 출력 하는 방법을 보여 줍니다.The following example shows how to create, initialize and perform various functions to a Hashtable and how to print out its keys and values.

using namespace System;
using namespace System::Collections;

public ref class Example
{
public:
    static void Main()
    {
        // Create a new hash table.
        //
        Hashtable^ openWith = gcnew Hashtable();
        
        // Add some elements to the hash table. 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 hash table.
        try
        {
            openWith->Add("txt", "winword.exe");
        }
        catch(...)
        {
            Console::WriteLine("An element with Key = \"txt\" already exists.");
        }

        // 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";

        // 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 hash table elements,
        // the elements are retrieved as KeyValuePair objects.
        Console::WriteLine();
        for each( DictionaryEntry de in openWith )
        {
            Console::WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
        }

        // To get the values alone, use the Values property.
        ICollection^ valueColl = openWith->Values;
        
        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for hash table values.
        Console::WriteLine();
        for each( String^ s in valueColl )
        {
            Console::WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        ICollection^ keyColl = openWith->Keys;
        
        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for hash table 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.
Value added for key = "ht": hypertrm.exe

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

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

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

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

class Example
{
    public static void Main()
    {
        // Create a new hash table.
        //
        Hashtable openWith = new Hashtable();
        
        // Add some elements to the hash table. 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 hash table.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // 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";

        // 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 hash table elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( DictionaryEntry de in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
        }

        // To get the values alone, use the Values property.
        ICollection valueColl = openWith.Values;
        
        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for hash table values.
        Console.WriteLine();
        foreach( string s in valueColl )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        ICollection keyColl = openWith.Keys;
        
        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for hash table 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.
Value added for key = "ht": hypertrm.exe

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

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

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

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

Module Example

    Sub Main()

        ' Create a new hash table.
        '
        Dim openWith As New Hashtable()

        ' Add some elements to the hash table. 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 hash table.
        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"

        ' 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 hash table elements,
        ' the elements are retrieved as KeyValuePair objects.
        Console.WriteLine()
        For Each de As DictionaryEntry In openWith
            Console.WriteLine("Key = {0}, Value = {1}", _
                de.Key, de.Value)
        Next de

        ' To get the values alone, use the Values property.
        Dim valueColl As ICollection = openWith.Values

        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for hash table 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 ICollection = openWith.Keys

        ' The elements of the KeyCollection are strongly typed
        ' with the type that was specified for hash table 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 Module

' 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.
'Value added for key = "ht": hypertrm.exe
'
'Key = dib, Value = paint.exe
'Key = txt, Value = notepad.exe
'Key = ht, Value = hypertrm.exe
'Key = bmp, Value = paint.exe
'Key = rtf, Value = winword.exe
'Key = doc, Value = winword.exe
'
'Value = paint.exe
'Value = notepad.exe
'Value = hypertrm.exe
'Value = paint.exe
'Value = winword.exe
'Value = winword.exe
'
'Key = dib
'Key = txt
'Key = ht
'Key = bmp
'Key = rtf
'Key = doc
'
'Remove("doc")
'Key "doc" is not found.
# Create new hash table using PowerShell syntax
$OpenWith = @{}

# Add one element to the hash table using the Add method
$OpenWith.Add('txt', 'notepad.exe')

# Add three eleements using PowerShell syntax three different ways
$OpenWith.dib = 'paint.exe'

$KeyBMP = 'bmp'
$OpenWith[$KeyBMP] = 'paint.exe'

$OpenWith += @{'rtf' = 'wordpad.exe'}

# Display hash table
"There are {0} in the `$OpenWith hash table as follows:" -f $OpenWith.Count
''

# Display hashtable properties
'Count of items in the hashtable  : {0}' -f $OpenWith.Count
'Is hashtable fixed size?         : {0}' -f $OpenWith.IsFixedSize
'Is hashtable read-only?          : {0}' -f $OpenWith.IsReadonly
'Is hashtabale synchronised?      : {0}' -f $OpenWith.IsSynchronized
''
'Keys in hashtable:'
$OpenWith.Keys
''
'Values in hashtable:'
$OpenWith.Values
''

<#
This script produces the following output:

There are 4 in the $OpenWith hash table as follows:

Name                           Value                                                                            
----                           -----                                                                            
txt                            notepad.exe                                                                      
dib                            paint.exe                                                                        
bmp                            paint.exe                                                                        
rtf                            wordpad.exe                                                                      

Count of items in the hashtable  : 4
Is hashtable fixed size?         : False
Is hashtable read-only?          : False
Is hashtabale synchronised?      : False

Keys in hashtable:
txt
dib
bmp
rtf

Values in hashtable:
notepad.exe
paint.exe
paint.exe
wordpad.exe
#>

설명

각 요소는 DictionaryEntry 개체에 저장 된 키/값 쌍입니다.Each element is a key/value pair stored in a DictionaryEntry object. 키는 null수 없지만 값은 일 수 있습니다.A key cannot be null, but a value can be.

중요

새 개발에는 Hashtable 클래스를 사용 하지 않는 것이 좋습니다.We don't recommend that you use the Hashtable class for new development. 대신 제네릭 Dictionary<TKey,TValue> 클래스를 사용 하는 것이 좋습니다.Instead, we recommend that you use the generic Dictionary<TKey,TValue> class. 자세한 내용은 GitHub에서 제네릭이 아닌 컬렉션을 사용 하지 않아야 합니다.For more information, see Non-generic collections shouldn't be used on GitHub.

Hashtable에서 키로 사용 하는 개체는 Object.GetHashCode 메서드 (또는 IHashCodeProvider 인터페이스) 및 Object.Equals 메서드 (또는 IComparer 인터페이스)를 재정의 하는 데 필요 합니다.The objects used as keys by a Hashtable are required to override the Object.GetHashCode method (or the IHashCodeProvider interface) and the Object.Equals method (or the IComparer interface). 메서드와 인터페이스를 모두 구현 하는 경우 대/소문자 구분을 동일한 방식으로 처리 해야 합니다. 그렇지 않으면 Hashtable 올바르게 동작 하지 않을 수 있습니다.The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. 예를 들어 Hashtable를 만들 때 CaseInsensitiveComparer 클래스 (또는 대/소문자를 구분 하지 않는 IComparer 구현)를 사용 하 여 CaseInsensitiveHashCodeProvider 클래스 (또는 대/소문자를 구분 하지 않는 IHashCodeProvider 구현)를 사용 해야 합니다.For example, when creating a Hashtable, you must use the CaseInsensitiveHashCodeProvider class (or any case-insensitive IHashCodeProvider implementation) with the CaseInsensitiveComparer class (or any case-insensitive IComparer implementation).

또한 이러한 메서드는 키가 Hashtable에 있는 동안 동일한 매개 변수를 사용 하 여 호출 될 때 동일한 결과를 생성 해야 합니다.Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. 다른 방법은 IEqualityComparer 매개 변수와 함께 Hashtable 생성자를 사용 하는 것입니다.An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. 키가 동등 하 게 일치 하는 경우에만 Object.GetHashCodeObject.Equals의 상속 된 구현에서 충분 합니다.If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

키 개체를 Hashtable키로 사용 하는 경우에는 변경할 수 없어야 합니다.Key objects must be immutable as long as they are used as keys in the Hashtable.

요소가 Hashtable에 추가 되 면 요소는 키의 해시 코드에 따라 버킷에 배치 됩니다.When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. 후속 조회 키의 키의 해시 코드를 사용 하 여 검색할 하나만 특정 버킷의 요소를 찾는 데 필요한 키 비교 수가 상당히 감소 합니다.Subsequent lookups of the key use the hash code of the key to search in only one particular bucket, thus substantially reducing the number of key comparisons required to find an element.

Hashtable의 로드 비율은 버킷에 대 한 요소의 최대 비율을 결정 합니다.The load factor of a Hashtable determines the maximum ratio of elements to buckets. 더 작은 부하 요인으로 인해 메모리 사용 증가 하는 대신 더 빠르게 평균 조회 시간입니다.Smaller load factors cause faster average lookup times at the cost of increased memory consumption. 일반적으로 1.0의 기본 로드 비율 속도 크기 간의 최상의 균형을 제공합니다.The default load factor of 1.0 generally provides the best balance between speed and size. Hashtable 만들어질 때 다른 로드 비율을 지정할 수도 있습니다.A different load factor can also be specified when the Hashtable is created.

요소가 Hashtable에 추가 되 면 Hashtable의 실제 로드 비율이 늘어납니다.As elements are added to a Hashtable, the actual load factor of the Hashtable increases. 실제 로드 비율이 지정 된 로드 비율에 도달 하면 Hashtable의 버킷 수가 현재 Hashtable 버킷 수보다 두 배 큰 가장 작은 소수 값으로 자동으로 증가 합니다.When the actual load factor reaches the specified load factor, the number of buckets in the Hashtable is automatically increased to the smallest prime number that is larger than twice the current number of Hashtable buckets.

Hashtable의 각 키 개체는 GetHash를 호출 하 여 액세스할 수 있는 고유한 해시 함수를 제공 해야 합니다.Each key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. 그러나 IHashCodeProvider를 구현 하는 모든 개체를 Hashtable 생성자에 전달할 수 있으며이 해시 함수는 테이블의 모든 개체에 사용 됩니다.However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

Hashtable 용량은 Hashtable에서 보유할 수 있는 요소의 수입니다.The capacity of a Hashtable is the number of elements the Hashtable can hold. 요소가 Hashtable에 추가 되 면 재할당을 통해 필요에 따라 용량이 자동으로 증가 합니다.As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

.NET Framework에만 해당: 매우 큰 Hashtable 개체의 경우 <gcAllowVeryLargeObjects> 구성 요소의 enabled 특성을 런타임 환경에서 true로 설정 하 여 64 비트 시스템에서 최대 용량을 20억 요소로 늘릴 수 있습니다..NET Framework only: For very large Hashtable 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 문 (Visual Basic의For Each)은 컬렉션의 요소 형식에 대 한 개체를 반환 합니다.The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Hashtable의 각 요소는 키/값 쌍 이므로 요소 형식은 키의 형식이 나 값의 형식이 아닙니다.Since each element of the Hashtable is a key/value pair, the element type is not the type of the key or the type of the value. 대신 요소 형식이 DictionaryEntry됩니다.Instead, the element type is DictionaryEntry. 다음은 그 예입니다.For example:

for each(DictionaryEntry de in myHashtable)
{
    // ...
}
foreach(DictionaryEntry de in myHashtable)
{
    // ...
}
For Each de As DictionaryEntry In myHashtable
    ' ...
Next de

foreach 문은 컬렉션에 쓰지 않고 읽을 수 있는 열거자에 대 한 래퍼입니다.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Hashtable 열거자를 serialize 하 고 deserialize 하면 요소가 다시 정렬 될 수 있으므로 Reset 메서드를 호출 하지 않고 열거형을 계속할 수 없습니다.Because serializing and deserializing an enumerator for a Hashtable can cause the elements to become reordered, it is not possible to continue enumeration without calling the Reset method.

참고

키를 상속 하 고 해당 동작을 변경할 수 있기 때문에 Equals 메서드를 사용 하 여 비교 하면 절대 고유성이 보장 되지 않습니다.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

생성자

Hashtable()

기본 초기 용량, 로드 비율, 해시 코드 공급자 및 비교자를 사용하여 Hashtable 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the default initial capacity, load factor, hash code provider, and comparer.

Hashtable(IDictionary)

지정한 사전의 요소를 새 Hashtable 개체에 복사하여 Hashtable 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Hashtable 개체는 복사된 요소 수와 같은 초기 용량을 갖고 있고 기본 로드 비율, 해시 코드 공급자 및 비교자를 사용합니다.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, hash code provider, and comparer.

Hashtable(IDictionary, IEqualityComparer)

지정된 사전의 요소를 새 Hashtable 개체에 복사하여 Hashtable 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. Hashtable 개체는 복사된 요소 수와 같은 초기 용량을 갖고 있고 기본 로드 비율과 지정된 IEqualityComparer 개체를 사용합니다.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor and the specified IEqualityComparer object.

Hashtable(IDictionary, IHashCodeProvider, IComparer)

지정한 사전의 요소를 새 Hashtable 개체에 복사하여 Hashtable 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Hashtable 개체는 복사된 요소 수와 같은 초기 용량을 갖고 있고 기본 로드 비율과 지정된 해시 코드 공급자 및 비교자를 사용합니다.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, and the specified hash code provider and comparer. 이 API는 더 이상 사용되지 않습니다.This API is obsolete. 다른 방법을 보려면 Hashtable(IDictionary, IEqualityComparer)를 참조하십시오.For an alternative, see Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single)

지정한 사전의 요소를 새 Hashtable 개체에 복사하여 Hashtable 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Hashtable 개체는 복사된 요소 수와 같은 초기 용량을 갖고 있고 지정된 로드 비율과 기본 해시 코드 공급자 및 비교자를 사용합니다.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, and the default hash code provider and comparer.

Hashtable(IDictionary, Single, IEqualityComparer)

지정한 사전의 요소를 새 Hashtable 개체에 복사하여 Hashtable 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Hashtable 개체는 복사된 요소 수와 같은 초기 용량을 갖고 있고 지정된 로드 비율 및 IEqualityComparer 개체를 사용합니다.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor and IEqualityComparer object.

Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)

지정한 사전의 요소를 새 Hashtable 개체에 복사하여 Hashtable 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Hashtable 개체는 복사된 요소 수와 같은 초기 용량을 갖고 있고 지정된 로드 비율, 해시 코드 공급자 및 비교자를 사용합니다.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, hash code provider, and comparer.

Hashtable(IEqualityComparer)

기본 초기 용량 및 로드 비율과 지정된 Hashtable 개체를 사용하여 IEqualityComparer 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified IEqualityComparer object.

Hashtable(IHashCodeProvider, IComparer)

기본 초기 용량 및 로드 비율과 지정된 해시 코드 공급자 및 비교자를 사용하여 Hashtable 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified hash code provider and comparer.

Hashtable(Int32)

지정된 초기 용량과 기본 로드 비율, 해시 코드 공급자 및 비교자를 사용하여 Hashtable 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, and the default load factor, hash code provider, and comparer.

Hashtable(Int32, IEqualityComparer)

지정된 초기 용량 및 Hashtable와 기본 로드 비율을 사용하여 IEqualityComparer 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and IEqualityComparer, and the default load factor.

Hashtable(Int32, IHashCodeProvider, IComparer)

지정된 초기 용량, 해시 코드 공급자 및 비교자와 기본 로드 비율을 사용하여 Hashtable 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, hash code provider, comparer, and the default load factor.

Hashtable(Int32, Single)

지정된 초기 용량 및 로드 비율과 기본 해시 코드 공급자 및 비교자를 사용하여 Hashtable 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and load factor, and the default hash code provider and comparer.

Hashtable(Int32, Single, IEqualityComparer)

지정된 초기 용량, 로드 비율 및 Hashtable 개체를 사용하여 IEqualityComparer 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, and IEqualityComparer object.

Hashtable(Int32, Single, IHashCodeProvider, IComparer)

지정된 초기 용량, 로드 비율, 해시 코드 공급자 및 비교자를 사용하여 Hashtable 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, hash code provider, and comparer.

Hashtable(SerializationInfo, StreamingContext)

지정된 HashtableSerializationInfo 개체를 사용하여 serialize할 수 있는 StreamingContext 클래스의 비어 있는 새 인스턴스를 초기화합니다.Initializes a new, empty instance of the Hashtable class that is serializable using the specified SerializationInfo and StreamingContext objects.

속성

comparer

IComparer에 사용할 Hashtable를 가져오거나 설정합니다.Gets or sets the IComparer to use for the Hashtable.

Count

Hashtable에 포함된 키/값 쌍의 수를 가져옵니다.Gets the number of key/value pairs contained in the Hashtable.

EqualityComparer

IEqualityComparer에 사용할 Hashtable를 가져옵니다.Gets the IEqualityComparer to use for the Hashtable.

hcp

해시 코드를 분배할 수 있는 개체를 가져오거나 설정합니다.Gets or sets the object that can dispense hash codes.

IsFixedSize

Hashtable이 고정 크기인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the Hashtable has a fixed size.

IsReadOnly

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

IsSynchronized

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

Item[Object]

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

Keys

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

SyncRoot

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

Values

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

메서드

Add(Object, Object)

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

Clear()

Hashtable에서 모든 요소를 제거합니다.Removes all elements from the Hashtable.

Clone()

Hashtable의 부분 복사본을 만듭니다.Creates a shallow copy of the Hashtable.

Contains(Object)

Hashtable에 특정 키가 들어 있는지 여부를 확인합니다.Determines whether the Hashtable contains a specific key.

ContainsKey(Object)

Hashtable에 특정 키가 들어 있는지 여부를 확인합니다.Determines whether the Hashtable contains a specific key.

ContainsValue(Object)

Hashtable에 특정 값이 포함되어 있는지 여부를 확인합니다.Determines whether the Hashtable contains a specific value.

CopyTo(Array, Int32)

Hashtable 요소를 지정한 인덱스의 1차원 Array 인스턴스에 복사합니다.Copies the Hashtable elements to a one-dimensional Array instance at the specified index.

Equals(Object)

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

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

IDictionaryEnumerator를 반복하는 Hashtable를 반환합니다.Returns an IDictionaryEnumerator that iterates through the Hashtable.

GetHash(Object)

지정한 키의 해시 코드를 반환합니다.Returns the hash code for the specified key.

GetHashCode()

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

(다음에서 상속됨 Object)
GetObjectData(SerializationInfo, StreamingContext)

ISerializable 인터페이스를 구현하고 Hashtable을 serialize하는 데 필요한 데이터를 반환합니다.Implements the ISerializable interface and returns the data needed to serialize the Hashtable.

GetType()

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

(다음에서 상속됨 Object)
KeyEquals(Object, Object)

특정 ObjectHashtable의 특정 키와 비교합니다.Compares a specific Object with a specific key in the Hashtable.

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

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

Synchronized(Hashtable)

Hashtable에 대해 동기화되어 스레드로부터 안전하게 보호되는 래퍼를 반환합니다.Returns a synchronized (thread-safe) wrapper for the Hashtable.

ToString()

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

(다음에서 상속됨 Object)

명시적 인터페이스 구현

IEnumerable.GetEnumerator()

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

확장 메서드

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.

적용 대상

스레드 보안

Hashtable는 여러 판독기 스레드와 단일 쓰기 스레드에서 사용할 수 있는 스레드로부터 안전 합니다.Hashtable is thread safe for use by multiple reader threads and a single writing thread. 스레드 중 하나만 쓰기 (업데이트) 작업을 수행 하는 경우 다중 스레드 사용에 대 한 스레드로부터 안전 합니다 .이 경우 기록기가 Hashtable로 serialize 되는 경우 잠금이 해제 된 읽기를 허용 합니다.It is thread safe for multi-thread use when only one of the threads perform write (update) operations, which allows for lock-free reads provided that the writers are serialized to the Hashtable. 여러 작성기를 지원 하려면 Hashtable 개체를 읽는 스레드가 없는 경우 Synchronized(Hashtable) 메서드에서 반환 하는 래퍼를 통해 Hashtable의 모든 작업을 수행 해야 합니다.To support multiple writers all operations on the Hashtable must be done through the wrapper returned by the Synchronized(Hashtable) method, provided that there are no threads reading the Hashtable object.

컬렉션을 열거 되지 본질적으로 스레드로부터 안전한 프로시저가 있습니다.Enumerating through a collection is intrinsically not a thread safe procedure. 컬렉션이 동기화되어 있을 때 다른 스레드에서 해당 컬렉션을 수정할 수 있으므로 이렇게 되면 열거자에서 예외가 throw됩니다.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 열거하는 동안 스레드로부터 안전을 보장하려면 전체 열거를 수행하는 동안 컬렉션을 잠그거나 다른 스레드에서 변경된 내용으로 인해 발생한 예외를 catch하면 됩니다.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

추가 정보