Differences between hashtable and dictionary types

Hashtable and dictionary <K, V> types
1: dictionary is recommended in a single-threaded program. It has the wildcard advantage, fast reading speed, and sufficient capacity utilization.
2: hashtable is recommended in multi-threaded programs. The default hashtable allows single-threaded writing and multi-threaded reading. For hashtable, the synchronized () method can be further called to obtain a completely thread-safe type. dictionary is NOT thread-safe and must be manually protected using the lock statement, greatly reducing the efficiency.
3

It is convenient to use dictionary.

Hashtable class and dictionary <(of <(tkey, tvalue>) generic class implement idictionary Interface

Dictionary <(of <(tkey, tvalue>) generic classes also implement idictionary <(of <(tkey, tvalue>) Generic interfaces. Therefore, each element in these sets

All are key/value pairs.

Dictionary <(of <(tkey, tvalue>) has the same functions as hashtable.
For value types, the performance of the Dictionary of a specific type (excluding objects) <(of <(tkey, tvalue>)> is better than that of hashtable, because hashtable

The elements of are of the object type. Therefore, the packing and unboxing operations are usually triggered when the value type is stored or retrieved.

Hashtable ht = new hashtable (); // implement the idictionary Interface
Ht. Add (1, "");
Ht. Add (2, "B ");
Ht. Add (3, "C ");
Foreach (dictionaryentry de in HT) // hashtable returns the dictionaryentry type
{
De. Key;
De. value;
}

Dictionary <int, string> mydictionary = new dictionary <int, string> (); // implements the idictionary interface and the idictionary <t key, T value> class.
Mydictionary. Add (1, "");
Mydictionary. Add (2, "B ");
Mydictionary. Add (3, "C ");
Foreach (int I in mydictionary. Keys)
{
Console. writeline ("Key =" + I + "value =" + mydictionary );
}
Or
Foreach (keyvaluepair <string, double> temp in mydictionary) // The returned keyvaluepair <string, double> Generic Array
{
Temp. Key;
Temp. value;
}

// An exception occurs if the key does not exist when you use the indexer.
Try
{
Console. writeline ("nonexistent key" "fff" "has the following key values:" + mydic ["fff"]);
}
Catch (keynotfoundexception ex)
{
Console. writeline ("the key is not found and an exception is thrown:" + ex. Message );
}
// The method to solve the above exception is to use contarnskey () to determine if a key exists. If you need to calculate the health worth frequently, it is best to use trygetvalue to obtain the set.

Corresponding Key Value in
String value = "";
If (mydictionary. trygetvalue ("fff", out value ))
{
Console. writeline ("nonexistent key" "fff" "has the following key values:" + value );
}
Else
{
Console. writeline ("the corresponding key value is not found ");
}

// Use foreach below to Traverse Key-value pairs
// The generic struct is used to store the key-value pair.
Foreach (keyvaluepair <string, string> temp in mydictionary)
{
Console. writeline (temp. Key, temp. value );
}
// Obtain a set of values
Foreach (string s in mydictionary. values)
{
Console. writeline ("value" + S );
}
// Another method is worth obtaining
Dictionary <string, string>. valuecollection values = mydictionary. values;
Foreach (string s in values)
{
Console. writeline ("value:" + S );
}
Common attributes and methods are as follows: common attributes
Attribute description
Comparer
Obtain the iequalitycomparer used to determine whether the keys in the dictionary are equal.
Count
Obtains the number of key/value pairs contained in a dictionary.
Item
Gets or sets the value associated with the specified key.
Keys
Obtains a set of keys in a dictionary.
Values
Obtains a set of values in a dictionary.

Add mydictionary. Add (string key, double value );
Adds the specified key and value to the dictionary.

Clear mydictionary. Clear ();
Remove all keys and values from dictionary.

Containskey mydictionary. containskey (string key );
Determines whether a dictionary contains the specified key.
Containsvalue mydictionary. containsvalue (double value)
Determines whether a dictionary contains a specific value.

Equals
Overloaded. Determine whether the two object instances are equal. (Inherit from object .)

Getenumerator mydictionary. getenumerator (new dictionary <string, double> ("AAA", 11.11 );
Returns the number of enumerations that access the dictionary cyclically.

Gethashcode
Used as a hash function of a specific type. Gethashcode is applicable to hash algorithms and data structures (such as hash tables. (Inherit from object .)

Getobjectdata
Implement the system. runtime. serialization. iserializable interface and return the data required to serialize the dictionary instance.

GetType
Obtain the type of the current instance. (Inherit from object .)

Ondeserialization
Implement the system. runtime. serialization. iserializable interface and trigger a deserialization event after deserialization.

Referenceequals
Determine whether the specified object instance is the same. (Inherit from object .)

Remove
Removes the value of the specified key from dictionary.

Tostring
Returns the string of the current object. (Inherit from object .)

Trygetvalue mydictionary. trygetvalue (string key, out double value); note that all out variables must be declared before

That is, double valuetest

If (! Mydictionary. trygetvalue (Key, out valuetest ))

Valuetest = 0.0; // if such a key value does not exist