为什么字典在 C# 中优于 Hashtable？

Question

在大多数编程语言中，字典比哈希表更受欢迎。 背后的原因是什么？

Answer 1

就其价值而言，字典是（概念上）一个哈希表。

如果您的意思是“为什么我们使用 Dictionary<TKey, TValue> 类而不是 Hashtable 类？”，那么答案很简单：Dictionary<TKey, TValue> 是泛型类型，Hashtable 不是。这意味着您可以使用 Dictionary<TKey, TValue> 获得类型安全，因为您不能将任何随机对象插入其中，并且您不必强制转换取出的值。

有趣的是，.NET Framework 中的Dictionary<TKey, TValue> 实现基于Hashtable，您可以从源代码中的这条评论看出：

通用字典是从 Hashtable 的源中复制的

Source

Answer 2

区别

Dictionary	Hashtable
Generic	Non-Generic
Needs own thread synchronization	Offers thread safe version through Synchronized() method
Enumerated item: KeyValuePair	Enumerated item: DictionaryEntry
Newer (> .NET 2.0)	Older (since .NET 1.0)
is in System.Collections.Generic	is in System.Collections
Request to non-existing key throws exception	Request to non-existing key returns null
potentially a bit faster for value types	bit slower (needs boxing/unboxing) for value types

相似之处：

• 两者都是内部哈希表 ==根据键快速访问多项数据
• 两者都需要不可变且唯一的键
• 两者的密钥都需要自己的GetHashCode()方法

替代 .NET 集合：

（代替字典和哈希表的候选）

• ConcurrentDictionary - 线程安全（可以同时从多个线程安全访问）
• HybridDictionary - 优化性能（适用于少数项目，也适用于许多项目）
• OrderedDictionary - 值可以通过 int index 访问（按添加项目的顺序）
• SortedDictionary - 项目自动排序
• StringDictionary - 强类型和为字符串优化（现在不推荐使用 Dictionary）

Answer 3

因为Dictionary 是一个泛型类（Dictionary<TKey, TValue>），所以访问它的内容是类型安全的（即你不需要像使用Hashtable 那样从Object 进行转换）。

比较

var customers = new Dictionary<string, Customer>();
...
Customer customer = customers["Ali G"];

到

var customers = new Hashtable();
...
Customer customer = customers["Ali G"] as Customer;

但是，Dictionary 在内部实现为哈希表，因此从技术上讲，它的工作方式相同。

Answer 4

仅供参考：在 .NET 中，Hashtable 是线程安全的，可供多个读取线程和单个写入线程使用，而在 Dictionary 中，公共静态成员是线程安全的，但不保证任何实例成员都是线程安全的.

因此，我们不得不将所有字典改回Hashtable。

Answer 5

在 .NET 中，Dictionary<,> 和 HashTable 之间的区别主要在于前者是泛型类型，因此您可以获得泛型在静态类型检查方面的所有好处（并减少装箱，但这不是t 与人们在性能方面倾向于认为的一样大 - 不过，拳击有一定的内存成本）。

Answer 6

人们说字典和哈希表是一样的。

这不一定是真的。哈希表是实现字典的一种方式。一个典型的，它可能是 .NET 中 Dictionary 类中的默认一个，但根据定义它不是唯一的。

您同样可以使用链表或搜索树来实现字典，只是效率不高（对于某些效率指标）。

Answer 7

Collections & Generics 对于处理对象组很有用。在 .NET 中，所有集合对象都位于接口IEnumerable 下，而该接口又具有ArrayList(Index-Value)) 和HashTable(Key-Value)。在 .NET framework 2.0 之后，ArrayList & HashTable 被替换为 List & Dictionary。现在，Arraylist 和 HashTable 在当今的项目中不再使用。

谈到HashTable 和Dictionary 之间的区别，Dictionary 是通用的，而Hastable 不是通用的。我们可以将任何类型的对象添加到HashTable，但是在检索时我们需要将其转换为所需的类型。所以，它不是类型安全的。但是对于dictionary，我们可以在声明自己的同时指定key和value的类型，所以不需要在检索的时候进行强制转换。

我们来看一个例子：

哈希表

class HashTableProgram
{
    static void Main(string[] args)
    {
        Hashtable ht = new Hashtable();
        ht.Add(1, "One");
        ht.Add(2, "Two");
        ht.Add(3, "Three");
        foreach (DictionaryEntry de in ht)
        {
            int Key = (int)de.Key; //Casting
            string value = de.Value.ToString(); //Casting
            Console.WriteLine(Key + " " + value);
        }

    }
}

字典，

class DictionaryProgram
{
    static void Main(string[] args)
    {
        Dictionary<int, string> dt = new Dictionary<int, string>();
        dt.Add(1, "One");
        dt.Add(2, "Two");
        dt.Add(3, "Three");
        foreach (KeyValuePair<int, String> kv in dt)
        {
            Console.WriteLine(kv.Key + " " + kv.Value);
        }
    }
}

Answer 8

字典：

• 如果我们试图找到一个不存在的键，它会返回/抛出异常。

• 它比 Hashtable 更快，因为没有装箱和拆箱。

• 只有公共静态成员是线程安全的。

• 字典是一种通用类型，这意味着我们可以将它与任何数据类型一起使用（创建时，必须为键和值指定数据类型）。

  示例：Dictionary<string, string> <NameOfDictionaryVar> = new Dictionary<string, string>();

• Dictionay 是 Hashtable 的类型安全实现，Keys 和 Values 是强类型的。

哈希表：

• 如果我们试图找到一个不存在的键，它会返回 null。

• 它比字典慢，因为它需要装箱和拆箱。

• Hashtable 中的所有成员都是线程安全的，

• Hashtable 不是泛型，

• Hashtable是松散类型的数据结构，我们可以添加任意类型的键和值。

Answer 9

MSDN 上的Extensive Examination of Data Structures Using C# 文章指出冲突解决策略也有区别：

Hashtable 类使用一种称为rehashing 的技术。

重新散列的工作原理如下：有一组散列不同的函数， H₁ ... H_n，以及在从哈希中插入或检索项目时 表，最初使用 H₁ 散列函数。如果这导致 如果发生碰撞，则尝试 H₂，如果需要，可以尝试 H_n。

词典使用一种称为链接的技术。

使用重新散列，在发生冲突时重新计算散列，并尝试与散列对应的新槽。然而，对于链接，使用辅助数据结构来保存 任何碰撞。具体来说， Dictionary 中的每个插槽都有一个数组 映射到该存储桶的元素。发生碰撞时， 碰撞元素被添加到存储桶列表中。

Answer 10

从 .NET Framework 3.5 开始，还有一个 HashSet<T>，它提供了 Dictionary<TKey, TValue> 的所有优点，如果您只需要键而不需要值。

因此，如果您使用Dictionary<MyType, object> 并始终将值设置为null 来模拟类型安全哈希表，您可能应该考虑切换到HashSet<T>。

Answer 11

Hashtable 是一种松散类型的数据结构，因此您可以向Hashtable 添加任何类型的键和值。 Dictionary 类是类型安全的Hashtable 实现，键和值是强类型的。创建Dictionary 实例时，必须同时指定键和值的数据类型。

Answer 12

注意the documentation 说：“Dictionary)>) 类实现为 哈希表”，而不是“Dictionary)>) 类实现为 HashTable"

字典不是作为哈希表实现的，而是按照哈希表的概念来实现的。由于使用了泛型，该实现与 HashTable 类无关，尽管 Microsoft 在内部可以使用相同的代码并将 Object 类型的符号替换为 TKey 和 TValue。

在 .NET 1.0 中不存在泛型；这是 HashTable 和 ArrayList 最初开始的地方。

Answer 13

哈希表：

键/值在存储到堆中时会转换为对象（装箱）类型。

从堆中读取时需要将键/值转换为所需的类型。

这些操作非常昂贵。我们需要尽可能避免装箱/拆箱。

字典： HashTable 的通用变体。

没有装箱/拆箱。无需转换。

Answer 14

Hashtable 对象由包含集合元素的桶组成。存储桶是 Hashtable 中元素的虚拟子组，与大多数集合相比，它使搜索和检索变得更容易和更快。

Dictionary 类与 Hashtable 类具有相同的功能。对于值类型，特定类型（对象除外）比 Hashtable 具有更好的性能，因为 Hashtable 的元素属于 Object 类型，因此，如果存储或检索值类型。

进一步阅读：Hashtable and Dictionary Collection Types

Answer 15

另一个重要的区别是 Hashtable 是线程安全的。 Hashtable 具有内置的多读取器/单写入器 (MR/SW) 线程安全性，这意味着 Hashtable 允许一个写入器与多个读取器一起使用而无需锁定。

在 Dictionary 的情况下，没有线程安全；如果您需要线程安全，则必须实现自己的同步。

进一步阐述：

Hashtable 通过Synchronized 属性提供了一些线程安全性，该属性返回一个线程安全的集合包装。包装器通过在每次添加或删除操作时锁定整个集合来工作。因此，每个试图访问集合的线程都必须等待轮到它来获取一个锁。这是不可扩展的，并且可能导致大型集合的性能显着下降。此外，设计并未完全免受竞争条件的影响。

.NET Framework 2.0 集合类如List<T>, Dictionary<TKey, TValue> 等不提供任何线程同步；当在多个线程上同时添加或删除项目时，用户代码必须提供所有同步

如果您需要类型安全以及线程安全，请使用 .NET Framework 中的并发集合类。延伸阅读here。

另一个区别是，当我们在 Dictionary 中添加多个条目时，条目的添加顺序保持不变。当我们从 Dictionary 中检索项目时，我们将以插入它们的相同顺序获取记录。而 Hashtable 不保留插入顺序。

Answer 16

我能弄清楚的另一个区别是：

我们不能在 Web 服务中使用 Dictionary（泛型）。原因是没有 Web 服务标准支持泛型标准。

Answer 17

Dictionary<> 是泛型类型，因此它是类型安全的。

您可以在 HashTable 中插入任何值类型，这有时可能会引发异常。但是Dictionary<int> 只会接受整数值，同样Dictionary<string> 只会接受字符串。

所以，最好使用Dictionary<> 而不是HashTable。

Answer 18

在大多数编程语言中，字典比哈希表更受欢迎

我认为这不一定是真的，大多数语言都有其中一种，具体取决于terminology they prefer。

然而，在 C# 中，明确的原因（对我来说）是 C# HashTables 和 System.Collections 命名空间的其他成员在很大程度上已经过时。它们出现在 c# V1.1 中。从 C# 2.0 开始，它们已被 System.Collections.Generic 命名空间中的通用类取代。

Answer 19

根据我使用.NET Reflector看到的：

[Serializable, ComVisible(true)]
public abstract class DictionaryBase : IDictionary, ICollection, IEnumerable
{
    // Fields
    private Hashtable hashtable;

    // Methods
    protected DictionaryBase();
    public void Clear();
.
.
.
}
Take note of these lines
// Fields
private Hashtable hashtable;

所以我们可以确定 DictionaryBase 在内部使用了一个 HashTable。