因为Dictionary是一个泛型类（Dictionary＜TKey，TValue＞），所以访问其内容是类型安全的（即，不需要像Hashtable那样从Object转换）。

比较

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

to

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

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

从概念上讲，字典是一个哈希表。

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

有趣的是，.NET Framework中的Dictionary＜TKey，TValue＞实现是基于Hashtable的，您可以从其源代码中的注释中看出：

通用字典已从Hashtable的源复制

来源

Dictionary＜＞是泛型类型，因此它是类型安全的。

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

因此，最好使用Dictionary＜＞而不是HashTable。

集合和泛型对于处理一组对象非常有用。在.NET中，所有集合对象都位于接口IEnumerable下，该接口又具有ArrayList（索引值）和HashTable（键值）。在.NET framework 2.0之后，ArrayList和HashTable被List和Dictionary取代。现在，Arraylist和HashTable在现在的项目中不再使用。

谈到HashTable和Dictionary之间的区别，Dictionary是泛型的，而Hastable不是泛型的。我们可以向HashTable中添加任何类型的对象，但在检索时需要将其转换为所需的类型。因此，它不是类型安全的。但对于字典，在声明自身时，我们可以指定键和值的类型，因此在检索时不需要强制转换。

我们来看一个示例：

散列表

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);
        }
    }
}

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

在.NET中，Dictionary<，>和HashTable之间的区别主要在于前者是一种泛型类型，因此在静态类型检查方面可以获得泛型的所有好处（以及减少装箱，但这并不像人们在性能方面所想的那么大-尽管装箱会有一定的内存成本）。