Pourquoi le dictionnaire est-il préféré à Hashtable en C #?

Dans la plupart des langages de programmation, les dictionnaires sont préférés aux tables de hachage. Quelles en sont les raisons?

Pour ce qu'il vaut, un dictionnaire est (conceptuellement) une table de hachage.

Si vous vouliez dire "pourquoi utilisons-nous Dictionary<TKey, TValue> classe au lieu de la Hashtableclasse?", Alors c'est une réponse simple: Dictionary<TKey, TValue>est un type générique, Hashtablenon. Cela signifie que vous obtenez une sécurité de type avec Dictionary<TKey, TValue>, car vous ne pouvez pas insérer d'objet aléatoire dans celui-ci, et vous n'avez pas à transtyper les valeurs que vous supprimez.

Fait intéressant, l' Dictionary<TKey, TValue>implémentation dans le .NET Framework est basée sur le Hashtable, comme vous pouvez le voir dans ce commentaire dans son code source:

Le dictionnaire générique a été copié à partir de la source de Hashtable

La source

Dictionary<<< >>> Hashtabledifférences:

• Générique <<< >>> Non générique
• Nécessite une synchronisation des threads <<< >>> Offre une version thread-safe par la Synchronized()méthode
• Article KeyValuePairénuméré : <<< >>> Article énuméré:DictionaryEntry
• Plus récent (> .NET 2.0 ) <<< >>> Plus ancien (depuis .NET 1.0 )
• est dans System.Collections.Generic <<< >>> est dans System.Collections
• La requête vers une clé non existante renvoie une exception <<< >>> La requête vers une clé non existante renvoie null
• potentiellement un peu plus rapide pour les types de valeur <<< >>> bit plus lent (nécessite de la boxe / unboxing) pour les types de valeur

Dictionary/ Hashtablesimilitudes:

• Les deux sont des tables de hachage internes == accès rapide aux données à plusieurs éléments selon la clé
• Les deux ont besoin de clés immuables et uniques
• Les clés des deux nécessitent leur propre GetHashCode()méthode

Collections .NET similaires (candidats à utiliser à la place de Dictionary et Hashtable):

• ConcurrentDictionary- thread safe (accessible en toute sécurité à partir de plusieurs threads simultanément)
• HybridDictionary- performances optimisées (pour quelques articles et aussi pour de nombreux articles)
• OrderedDictionary- les valeurs sont accessibles via int index (par ordre dans lequel les éléments ont été ajoutés)
• SortedDictionary- articles triés automatiquement
• StringDictionary- fortement typé et optimisé pour les chaînes

Parce que Dictionaryc'est une classe générique ( Dictionary<TKey, TValue>), de sorte que l'accès à son contenu est de type sécurisé (c'est-à-dire que vous n'avez pas besoin de caster à partir de Object, comme vous le faites avec a Hashtable).

Comparer

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

à

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

Cependant, Dictionaryest implémenté en tant que table de hachage en interne, donc techniquement, cela fonctionne de la même manière.

FYI: Dans .NET, Hashtableest thread-safe pour une utilisation par plusieurs threads de lecture et un seul thread d'écriture, tandis que dans Dictionaryles membres statiques publics sont thread-safe, mais tous les membres d'instance ne sont pas garantis pour être thread-safe.

Nous avons dû changer tous nos dictionnaires à Hashtablecause de cela.

Dans .NET, la différence entre Dictionary<,>et HashTableest principalement que le premier est un type générique, donc vous obtenez tous les avantages des génériques en termes de vérification de type statique (et de boxe réduite, mais ce n'est pas aussi grand que les gens ont tendance à penser termes de performances - il y a un coût de mémoire certain pour la boxe, cependant).

Les gens disent qu'un dictionnaire est identique à une table de hachage.

Ce n'est pas nécessairement vrai. Une table de hachage est un moyen d' implémenter un dictionnaire. Un exemple typique à cela, et il peut être celui par défaut dans .NET dans la Dictionaryclasse, mais ce n'est pas par définition le seul.

Vous pourriez tout aussi bien implémenter un dictionnaire en utilisant une liste chaînée ou un arbre de recherche, ce ne serait tout simplement pas aussi efficace (pour une métrique d'efficacité).

Collections& Genericssont utiles pour gérer un groupe d'objets. Dans .NET, tous les objets de collections relèvent de l'interface IEnumerable, qui à son tour a ArrayList(Index-Value))& HashTable(Key-Value). Après .NET Framework 2.0, ArrayList& a HashTableété remplacé par List& Dictionary. Maintenant, le Arraylist& HashTablen'est plus utilisé dans les projets de nos jours.

Venant à la différence entre HashTable& Dictionary, Dictionaryest générique alors que as Hastablen'est pas générique. Nous pouvons ajouter n'importe quel type d'objet HashTable, mais lors de la récupération, nous devons le convertir en le type requis. Donc, ce n'est pas un type sûr. Mais dictionary, tout en se déclarant, nous pouvons spécifier le type de clé et de valeur, il n'est donc pas nécessaire de transtyper lors de la récupération.

Regardons un exemple:

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

    }
}

Dictionnaire,

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

Dictionnaire:

• Il retourne / lève une exception si nous essayons de trouver une clé qui n'existe pas.

• Il est plus rapide qu'un Hashtable car il n'y a ni boxe ni déballage.

• Seuls les membres statiques publics sont thread-safe.

• Le dictionnaire est un type générique, ce qui signifie que nous pouvons l'utiliser avec n'importe quel type de données (lors de la création, doit spécifier les types de données pour les clés et les valeurs).

  Exemple: Dictionary<string, string> <NameOfDictionaryVar> = new Dictionary<string, string>();

• Dictionay est une implémentation sécurisée de Hashtable Keyset Valuesest fortement typé.

Table de hachage:

• Il renvoie null si nous essayons de trouver une clé qui n'existe pas.

• Il est plus lent que le dictionnaire car il nécessite la boxe et le déballage.

• Tous les membres d'une table de hachage sont thread-safe,

• Hashtable n'est pas un type générique,

• Hashtable est une structure de données de type lâche, nous pouvons ajouter des clés et des valeurs de tout type.

L'article Examen approfondi des structures de données à l'aide de C # sur MSDN indique qu'il existe également une différence dans la stratégie de résolution des collisions :

La classe Hashtable utilise une technique appelée rehachage .

Le rehachage fonctionne comme suit: il existe un ensemble de fonctions de hachage différentes, H ₁ ... H _n , et lors de l'insertion ou de la récupération d'un élément de la table de hachage, la fonction de hachage H ₁ est initialement utilisée. Si cela conduit à une collision, H ₂ est essayé à la place et jusqu'à H _n si nécessaire.

Le dictionnaire utilise une technique appelée chaînage .

Avec le rehachage, en cas de collision, le hachage est recalculé et le nouvel emplacement correspondant à un hachage est essayé. Avec le chaînage, cependant, une structure de données secondaire est utilisée pour contenir les collisions . Plus précisément, chaque emplacement du dictionnaire possède un tableau d'éléments qui correspondent à ce compartiment. En cas de collision, l'élément en collision est ajouté à la liste du compartiment.

Depuis .NET Framework 3.5, il existe également un HashSet<T>qui fournit tous les avantages de laDictionary<TKey, TValue> si vous n'avez besoin que des clés et pas de valeurs.

Donc, si vous utilisez un Dictionary<MyType, object>et définissez toujours la valeur sur nullpour simuler la table de hachage sécurisée de type, vous devriez peut-être envisager de basculer vers le HashSet<T>.

La Hashtablestructure de données est typée de manière lâche, vous pouvez donc ajouter des clés et des valeurs de tout type à la Hashtable. La Dictionaryclasse est une Hashtableimplémentation de type sécurisé , et les clés et les valeurs sont fortement typées. Lors de la création d'une Dictionaryinstance, vous devez spécifier les types de données pour la clé et la valeur.

Notez que MSDN dit: "La classe Dictionary <(Of <(TKey, TValue>)>) est implémentée en tant que table de hachage ", et non la classe "Dictionary <(Of <(TKey, TValue>)>) est implémentée en tant que HashTable "

Le dictionnaire n'est PAS implémenté en tant que HashTable, mais il est implémenté suivant le concept d'une table de hachage. L'implémentation n'est pas liée à la classe HashTable en raison de l'utilisation de génériques, bien qu'en interne Microsoft aurait pu utiliser le même code et remplacer les symboles de type Object par TKey et TValue.

Dans .NET 1.0, les génériques n'existaient pas; c'est là que HashTable et ArrayList ont commencé à l'origine.

HashTable:

La clé / valeur sera convertie en un type d'objet (boxe) lors du stockage dans le tas.

La clé / valeur doit être convertie dans le type souhaité lors de la lecture à partir du tas.

Ces opérations sont très coûteuses. Nous devons éviter autant que possible la boxe / le déballage.

Dictionnaire: variante générique de HashTable.

Pas de boxe / déballage. Aucune conversion requise.

Un objet Hashtable se compose de compartiments qui contiennent les éléments de la collection. Un compartiment est un sous-groupe virtuel d'éléments dans la table de hachage, ce qui rend la recherche et la récupération plus faciles et plus rapides que dans la plupart des collections .

La classe Dictionary a les mêmes fonctionnalités que la classe Hashtable. Un dictionnaire d'un type spécifique (autre que Object) a de meilleures performances qu'une table de hachage pour les types de valeur car les éléments de la table de hachage sont de type objet et, par conséquent, la mise en boîte et la décompression se produisent généralement lors du stockage ou de la récupération d'un type de valeur.

Pour en savoir plus: Hashtable et Dictionary Collection Types

Une autre différence importante est que Hashtable est thread-safe. Hashtable a une sécurité de thread intégrée pour plusieurs lecteurs / écrivain unique (MR / SW), ce qui signifie que Hashtable permet à UN écrivain avec plusieurs lecteurs sans verrouillage.

Dans le cas de Dictionary, il n'y a pas de sécurité des threads; si vous avez besoin de la sécurité des threads, vous devez implémenter votre propre synchronisation.

Pour développer davantage:

Hashtable offre une certaine sécurité des threads via le Synchronized propriété, qui renvoie un wrapper thread-safe autour de la collection. L'encapsuleur fonctionne en verrouillant la collection entière à chaque opération d'ajout ou de suppression. Par conséquent, chaque thread qui tente d'accéder à la collection doit attendre son tour pour prendre le verrou. Ce n'est pas évolutif et peut entraîner une dégradation significative des performances pour les grandes collections. De plus, le design n'est pas complètement protégé des conditions de course.

Les classes de collection .NET Framework 2.0 comme List<T>, Dictionary<TKey, TValue>, etc. ne fournissent aucune synchronisation de thread; le code utilisateur doit fournir toute la synchronisation lorsque des éléments sont ajoutés ou supprimés simultanément sur plusieurs threads

Si vous avez besoin de la sécurité des types ainsi que de la sécurité des threads, utilisez des classes de collections simultanées dans le .NET Framework. Plus de lecture ici .

Une différence supplémentaire est que lorsque nous ajoutons les entrées multiples dans Dictionnaire, l'ordre dans lequel les entrées sont ajoutées est conservé. Lorsque nous récupérons les éléments du dictionnaire, nous obtenons les enregistrements dans le même ordre que nous les avons insérés. Tandis que Hashtable ne conserve pas l'ordre d'insertion.

Une autre différence que je peux comprendre est:

Nous ne pouvons pas utiliser Dictionary <KT, VT> (génériques) avec les services Web. La raison en est qu'aucune norme de service Web ne prend en charge la norme générique.

Dictionary<> est un type générique et il est donc sûr de type.

Vous pouvez insérer n'importe quel type de valeur dans HashTable et cela peut parfois lever une exception. Mais Dictionary<int>n'acceptera que les valeurs entières et Dictionary<string>n'acceptera que les chaînes.

Il est donc préférable d'utiliser Dictionary<>au lieu de HashTable.

Dans la plupart des langages de programmation, les dictionnaires sont préférés aux tables de hachage

Je ne pense pas que ce soit nécessairement vrai, la plupart des langues ont l'une ou l'autre, selon la terminologie qu'elles préfèrent .

En C #, cependant, la raison claire (pour moi) est que les tables de hachage C # et les autres membres de l'espace de noms System.Collections sont largement obsolètes. Ils étaient présents dans c # V1.1. Ils ont été remplacés à partir de C # 2.0 par les classes génériques dans l'espace de noms System.Collections.Generic.

Selon ce que je vois en utilisant .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;

Nous pouvons donc être sûrs que DictionaryBase utilise un HashTable en interne.