Hashtable Hashtable Hashtable Hashtable Class

Definition

키의 해시 코드에 따라 구성된 키/값 쌍의 컬렉션을 나타냅니다. 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
[System.Runtime.InteropServices.ComVisible(true)]
[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
Inheritance
HashtableHashtableHashtableHashtable
Derived
Attributes
ComVisibleAttribute SerializableAttribute
Implements

Examples

다음 예제에서는 만들기, 초기화 및 다양 한 함수를 수행 하는 방법을 보여 줍니다는 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
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
#>

Remarks

각 요소는에 저장 된 키/값 쌍을 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. 제네릭 사용 하는 권장 대신 HashSet<T> 클래스입니다.Instead, we recommend that you use the generic HashSet<T> 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를 사용 해야 합니다는 CaseInsensitiveHashCodeProvider 클래스 (또는 모든 대/소문자 IHashCodeProvider 구현) 사용 하 여를 CaseInsensitiveComparer 클래스 (모든 대/소문자 또는 IComparer 구현).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. 대신 사용 하는 것을 Hashtable 생성자를 IEqualityComparer 매개 변수입니다.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.

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

합니다 foreach C# 언어의 (For Each Visual basic에서) 컬렉션 요소의 형식의 개체를 반환 합니다.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 요소를 다시 정렬 될 하면, 호출 하지 않고 열거를 계속 불가능는 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.

Constructors

Hashtable() Hashtable() Hashtable() 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(IDictionary) Hashtable(IDictionary) 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(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer) 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(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer) 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(IDictionary, Single) Hashtable(IDictionary, Single) 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(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer) 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(IDictionary, Single, IHashCodeProvider, IComparer) Hashtable(IDictionary, Single, IHashCodeProvider, IComparer) 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) Hashtable(IEqualityComparer) 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(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer) 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(Int32) Hashtable(Int32) 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(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer) 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(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer) 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(Int32, Single) Hashtable(Int32, Single) 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(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer) 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(Int32, Single, IHashCodeProvider, IComparer) Hashtable(Int32, Single, IHashCodeProvider, IComparer) 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) Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext) 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.

Properties

comparer comparer comparer comparer

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

Count Count Count Count

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

EqualityComparer EqualityComparer EqualityComparer EqualityComparer

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

hcp hcp hcp hcp

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

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

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

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

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

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

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

Item[Object] Item[Object] Item[Object] Item[Object]

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

Keys Keys Keys Keys

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

SyncRoot SyncRoot SyncRoot SyncRoot

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

Values Values Values Values

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

Methods

Add(Object, Object) Add(Object, Object) Add(Object, Object) Add(Object, Object)

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

Clear() Clear() Clear() Clear()

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

Clone() Clone() Clone() Clone()

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

Contains(Object) Contains(Object) Contains(Object) Contains(Object)

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

ContainsKey(Object) ContainsKey(Object) ContainsKey(Object) ContainsKey(Object)

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

ContainsValue(Object) ContainsValue(Object) ContainsValue(Object) ContainsValue(Object)

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

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

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

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

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

GetHash(Object) GetHash(Object) GetHash(Object) GetHash(Object)

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

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

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

GetType() GetType() GetType() GetType()

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

(Inherited from Object)
KeyEquals(Object, Object) KeyEquals(Object, Object) KeyEquals(Object, Object) KeyEquals(Object, Object)

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

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
OnDeserialization(Object) OnDeserialization(Object) OnDeserialization(Object) OnDeserialization(Object)

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

Remove(Object) Remove(Object) Remove(Object) Remove(Object)

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

Synchronized(Hashtable) Synchronized(Hashtable) Synchronized(Hashtable) Synchronized(Hashtable)

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

ToString() ToString() ToString() ToString()

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

(Inherited from Object)

Explicit Interface Implementations

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

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

Applies to

Thread Safety

Hashtable 스레드를 여러 판독기 스레드 및 단일 쓰기 스레드가 사용 해도 안전 합니다. Hashtable is thread safe for use by multiple reader threads and a single writing thread. 이 스레드로부터 안전만 스레드 중 하나 (업데이트) 쓰기 작업을 수행할 때 다중 스레드 사용에 대 한 기록기 serialize 되는 읽기 잠금 해제 허용 하는 Hashtable합니다. 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.

See Also