Почему Dictionary предпочтительнее Hashtable в C#?

Поскольку Dictionary является универсальным классом (Dictionary<TKey, TValue>), поэтому доступ к его содержимому является типобезопасным (т.е. вам не нужно выполнять приведение из Object, как это делается с Hashtable).

Сравнивать

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

к

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

Однако Dictionary внутренне реализован в виде хеш-таблицы, поэтому технически он работает так же.

В .NET разница между Dictionary<,> и HashTable заключается в первую очередь в том, что первый является универсальным типом, поэтому вы получаете все преимущества универсальных типов с точки зрения проверки статического типа (и уменьшенного бокса, но это не так велико, как люди склонны. думаю с точки зрения производительности - правда, там боксу определенная стоимость памяти).

Hashtable представляет собой свободно типизированную структуру данных, поэтому вы можете добавлять в Hashtable ключи и значения любого типа. Класс Dictionary является типобезопасной реализацией Hashtable, а ключи и значения строго типизированы. При создании экземпляра Dictionary необходимо указать типы данных как для ключа, так и для значения.

Для чего это стоит, Dictionary является (концептуально) - хеш-таблица.

Если вы имели в виду «почему мы используем класс Dictionary<TKey, TValue> вместо класса Hashtable?», То это простой ответ: Dictionary<TKey, TValue> - это общий тип, а Hashtable - нет. Это означает, что вы получаете безопасность типов с Dictionary<TKey, TValue>, потому что вы не можете вставлять в него какой-либо случайный объект, и вам не нужно приводить значения, которые вы извлекаете.

Интересно, что реализация Dictionary<TKey, TValue> в .NET Framework основана на Hashtable, как вы можете видеть из этого комментария в его исходном коде:

The generic Dictionary was copied from Hashtable's source

Источник

К вашему сведению: в .NET Hashtable является потокобезопасным для использования несколькими потоками чтения и одним потоком записи, в то время как в Dictionary общедоступные статические члены являются потокобезопасными, но не гарантируется, что любые члены экземпляра будут потокобезопасными.

Из-за этого нам пришлось поменять все наши словари обратно на Hashtable.

Люди говорят, что словарь - это то же самое, что и хеш-таблица.

Это не обязательно правда. Хеш-таблица - это один из способов воплощать в жизнь словаря. При этом типичный, и он может быть по умолчанию в .NET в классе Dictionary, но по определению не единственный.

Вы могли бы с тем же успехом реализовать словарь, используя связанный список или дерево поиска, но это было бы не так эффективно (для некоторых показателей эффективности).

Еще одно различие, которое я могу понять:

Мы не можем использовать Dictionary <KT, VT> (generics) с веб-сервисами. Причина в том, что стандарт веб-сервисов не поддерживает стандарт универсальных шаблонов.

Обратите внимание, что документация говорит: «Класс Dictionary <(Of <(TKey, TValue>)>) реализован как хеш-таблица», а не «класс Dictionary <(Of <(TKey, TValue>)>) реализован как Хеш-таблица. "

Словарь НЕ реализован как HashTable, но реализован в соответствии с концепцией хеш-таблицы. Реализация не связана с классом HashTable из-за использования Generics, хотя внутри Microsoft могла бы использовать тот же код и заменить символы типа Object на TKey и TValue.

В .NET 1.0 Generics не существовало; здесь изначально начинались HashTable и ArrayList.

Согласно тому, что я вижу, используя .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.

Dictionary <<< >>> Hashtable отличия:

• Общий <<< >>> Не универсальный
• Требуется синхронизация собственного потока <<< >>> Предлагает версию потокобезопасный через метод Synchronized()
• Пронумерованный элемент: KeyValuePair <<< >>> Пронумерованный элемент: DictionaryEntry
• Новее (> .NET 2.0) <<< >>> Более раннее (начиная с .NET 1.0)
• находится в System.Collections.Generic <<< >>> находится в System.Collections
• Запрос к несуществующему ключу выдает исключение <<< >>> Запрос к несуществующему ключу возвращает ноль
• потенциально бит быстрее для типов значений <<< >>> немного медленнее (требуется упаковка / распаковка) для типов значений

Dictionary / Hashtable сходства:

• Оба внутренне хэш-таблицы == быстрый доступ к многопозиционным данным в соответствии с ключом
• Обоим нужен неизменные и уникальные ключи
• Ключам обоих нужен собственный метод GetHashCode()

Коллекции Похожий .NET (кандидаты для использования вместо Dictionary и Hashtable):

• ConcurrentDictionary - потокобезопасный (может быть безопасно доступен из нескольких потоков одновременно)
• HybridDictionary - оптимизированная производительность (для нескольких предметов, а также для многих предметов)
• OrderedDictionary - значения могут быть доступ через int index (по порядку добавления элементов)
• SortedDictionary - предметы автоматически сортируется
• StringDictionary - строго типизированный и оптимизирован для струнных

Dictionary<> - это универсальный тип, поэтому он безопасен по типу.

Вы можете вставить любой тип значения в HashTable, и это может иногда вызывать исключение. Но Dictionary<int> принимает только целочисленные значения, и аналогично Dictionary<string> принимает только строки.

Так что лучше использовать Dictionary<> вместо HashTable.

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, объявляя себя, мы можем указать тип ключа и значения, поэтому нет необходимости выполнять приведение при извлечении.

Давайте посмотрим на пример:

Хеш-таблица

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

Начиная с .NET Framework 3.5, существует также HashSet<T>, который предоставляет все преимущества Dictionary<TKey, TValue>, если вам нужны только ключи, а не значения.

Поэтому, если вы используете Dictionary<MyType, object> и всегда устанавливаете значение null для имитации типобезопасной хэш-таблицы, вам, возможно, следует подумать о переходе на HashSet<T>.

Объект Hashtable состоит из сегментов, содержащих элементы коллекции. Корзина - это виртуальная подгруппа элементов внутри хэш-таблицы, что делает поиск и извлечение проще и быстрее, чем в большинстве коллекций.

Класс Dictionary имеет ту же функциональность, что и класс Hashtable. Словарь определенного типа (кроме Object) имеет лучшую производительность, чем Hashtable для типов значений, поскольку элементы Hashtable относятся к типу Object, и, следовательно, упаковка и распаковка обычно происходят при сохранении или извлечении типа значения.

Для дальнейшего чтения: Типы коллекций хеш-таблиц и словарей

Словарь:

• Он возвращает / выдает исключение, если мы пытаемся найти несуществующий ключ.

• Это быстрее, чем Hashtable, потому что нет упаковки и распаковки.

• Только общедоступные статические члены являются потокобезопасными.

• Словарь - это общий тип, что означает, что мы можем использовать его с любым типом данных (при создании необходимо указать типы данных как для ключей, так и для значений).

  Пример: Dictionary<string, string> <NameOfDictionaryVar> = new Dictionary<string, string>();

• Dictionay - это типобезопасная реализация Hashtable, Keys и Values строго типизированы.

Хеш-таблица:

• Он возвращает ноль, если мы пытаемся найти несуществующий ключ.

• Он медленнее, чем словарь, потому что требует упаковки и распаковки.

• Все члены в Hashtable являются потокобезопасными,

• Hashtable не является универсальным типом,

• Hashtable - это слабо типизированная структура данных, мы можем добавлять ключи и значения любого типа.

В статье Обширное изучение структур данных с использованием C# на MSDN говорится, что есть разница в стратегия разрешения столкновений:

Класс Hashtable использует метод, называемый перефразирование.

Rehashing works as follows: there is a set of hash different functions, H₁ ... H_n, and when inserting or retrieving an item from the hash table, initially the H₁ hash function is used. If this leads to a collision, H₂ is tried instead, and onwards up to H_n if needed.

Словарь использует метод, называемый цепочка.

With rehashing, in the event of a collision the hash is recomputed, and the new slot corresponding to a hash is tried. With chaining, however, a secondary data structure is utilized to hold any collisions. Specifically, each slot in the Dictionary has an array of elements that map to that bucket. In the event of a collision, the colliding element is prepended to the bucket's list.

Еще одно важное отличие состоит в том, что Hashtable является потокобезопасным. Hashtable имеет встроенную безопасность потоков с несколькими читателями / одиночными записями (MR / SW), что означает, что Hashtable позволяет ОДИН писатель вместе с несколькими считывателями без блокировки.

В случае со словарем потокобезопасность отсутствует; если вам нужна потокобезопасность, вы должны реализовать свою собственную синхронизацию.

Для дальнейшего уточнения:

Hashtable provides some thread-safety through the Synchronized property, which returns a thread-safe wrapper around the collection. The wrapper works by locking the entire collection on every add or remove operation. Therefore, each thread that is attempting to access the collection must wait for its turn to take the one lock. This is not scalable and can cause significant performance degradation for large collections. Also, the design is not completely protected from race conditions.

The .NET Framework 2.0 collection classes like List<T>, Dictionary<TKey, TValue>, etc. do not provide any thread synchronization; user code must provide all synchronization when items are added or removed on multiple threads concurrently

Если вам нужна безопасность типов, а также безопасность потоков, используйте классы параллельных коллекций в .NET Framework. Дальнейшее чтение здесь.

Дополнительное отличие состоит в том, что при добавлении нескольких записей в словарь порядок, в котором они добавляются, сохраняется. Когда мы извлекаем элементы из Dictionary, мы получим записи в том же порядке, в котором мы их вставляли. В то время как Hashtable не сохраняет порядок вставки.

Хеш-таблица:

Ключ / значение будут преобразованы в тип объекта (бокса) при сохранении в куче.

Ключ / значение необходимо преобразовать в нужный тип при чтении из кучи.

Эти операции очень дороги. Нам нужно по возможности избегать упаковки / распаковки.

Словарь : Общий вариант HashTable.

Никакого бокса / распаковки. Никаких преобразований не требуется.

In most programming languages, dictionaries are preferred over hashtables

Я не думаю, что это обязательно так, в большинстве языков есть один или другой, в зависимости от терминология, которую они предпочитают.

Однако в C# очевидная причина (для меня) заключается в том, что C# HashTables и другие члены пространства имен System.Collections в значительной степени устарели. Они присутствовали в C# V1.1. В C# 2.0 они были заменены классами Generic в пространстве имен System.Collections.Generic.