Hashtable Class (System.Collections) (2024)

Definition

public ref class Hashtable : System::Collections::IDictionary

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable

public class Hashtable : System.Collections.IDictionary

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.Serializable][System.Runtime.InteropServices.ComVisible(true)]public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable

type Hashtable = class interface ICollection interface IEnumerable interface IDictionary

type Hashtable = class interface ICollection interface IEnumerable interface IDictionary interface ICloneable interface IDeserializationCallback interface ISerializable

type Hashtable = class interface ICollection interface IEnumerable interface IDictionary interface ISerializable interface IDeserializationCallback interface ICloneable

[<System.Serializable>]type Hashtable = class interface IDictionary interface ICollection interface IEnumerable interface ISerializable interface IDeserializationCallback interface ICloneable

[<System.Serializable>][<System.Runtime.InteropServices.ComVisible(true)>]type Hashtable = class interface IDictionary interface ICollection interface IEnumerable interface ISerializable interface IDeserializationCallback interface ICloneable

Public Class HashtableImplements IDictionary

Public Class HashtableImplements ICloneable, IDeserializationCallback, IDictionary, ISerializable

Inheritance

Object

Hashtable

See Also

Hashmap vs Hashtable: Understand the Differences with Examples | Hero ViredDifference Between HashMap and ConcurrentHashMapComparison of an Array and Hash table in terms of Storage structure and Access time complexity - GeeksforGeeks

Derived

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Attributes

SerializableAttributeComVisibleAttribute

Implements

ICollectionIDictionaryIEnumerableICloneableIDeserializationCallbackISerializable

Examples

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.exeKey = dib, Value = paint.exeKey = txt, Value = notepad.exeKey = ht, Value = hypertrm.exeKey = bmp, Value = paint.exeKey = rtf, Value = winword.exeKey = doc, Value = winword.exeValue = paint.exeValue = notepad.exeValue = hypertrm.exeValue = paint.exeValue = winword.exeValue = winword.exeKey = dibKey = txtKey = htKey = bmpKey = rtfKey = docRemove("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.exeKey = dib, Value = paint.exeKey = txt, Value = notepad.exeKey = ht, Value = hypertrm.exeKey = bmp, Value = paint.exeKey = rtf, Value = winword.exeKey = doc, Value = winword.exeValue = paint.exeValue = notepad.exeValue = hypertrm.exeValue = paint.exeValue = winword.exeValue = winword.exeKey = dibKey = txtKey = htKey = bmpKey = rtfKey = docRemove("doc")Key "doc" is not found. */

Imports System.CollectionsModule 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 SubEnd 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 elements 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 hashtable 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.exedib paint.exebmp paint.exertf wordpad.exeCount of items in the hashtable : 4Is hashtable fixed size? : FalseIs hashtable read-only? : FalseIs hashtable synchronised? : FalseKeys in hashtable:txtdibbmprtfValues in hashtable:notepad.exepaint.exepaint.exewordpad.exe#>

Remarks

Each element is a key/value pair stored in a DictionaryEntry object. A key cannot be null, but a value can be.

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). The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. 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).

Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Key objects must be immutable as long as they are used as keys in the 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.

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. The default load factor of 1.0 generally provides the best balance between speed and size. A different load factor can also be specified when the Hashtable is created.

As elements are added to a Hashtable, the actual load factor of the Hashtable increases. 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.

Each key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

The capacity of a Hashtable is the number of elements the Hashtable can hold. As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

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

The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. 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. 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

The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

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.

Constructors

Properties

Methods

Explicit Interface Implementations

Extension Methods

Applies to

Thread Safety

Hashtable is thread safe for use by multiple reader threads and a single writing thread. 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. 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. Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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

• IDictionary
• IHashCodeProvider
• GetHashCode()
• Equals(Object)
• DictionaryEntry
• Dictionary<TKey,TValue>
• IEqualityComparer