C#中字典集合HashTable、Dictionary、ConcurrentDictionary三者區別

C#中HashTable、Dictionary、ConcurrentDictionar三者都表示鍵/值對的集合，可是到底有什麼區別，下面詳細介紹

1、HashTable

HashTable表示鍵/值對的集合。在.NET Framework中，Hashtable是System.Collections命名空間提供的一個容器，用於處理和表現相似key-value的鍵值對，其中key一般可用來快速查找，同時key是區分大小寫；value用於存儲對應於key的值。Hashtable中key-value鍵值對均爲object類型，因此Hashtable能夠支持任何類型的keyvalue鍵值對，任何非 null 對象均可以用做鍵或值。

HashTable是一種散列表，他內部維護不少對Key-Value鍵值對，其還有一個相似索引的值叫作散列值(HashCode)，它是根據GetHashCode方法對Key經過必定算法獲取獲得的，全部的查找操做定位操做都是基於散列值來實現找到對應的Key和Value值的。

散列函數(GetHashCode)讓散列值對應HashTable的空間地址儘可能不重複。

當一個HashTable被佔用一大半的時候咱們經過計算散列值取得的地址值可能會重複指向同一地址，這就形成哈希衝突。

C#中鍵值對在HashTable中的位置Position= (HashCode& 0x7FFFFFFF) % HashTable.Length，C#是經過探測法解決哈希衝突的，當經過散列值取得的位置Postion以及被佔用的時候，就會增長一個位移x值判斷下一個位置Postion+x是否被佔用，若是仍然被佔用就繼續往下位移x判斷Position+2*x位置是否被佔用，若是沒有被佔用則將值放入其中。當HashTable中的可用空間愈來愈小時，則獲取獲得可用空間的難度愈來愈大，消耗的時間就越多。

使用方法以下：

using System;
using System.Collections;

namespace WebApp
{
    class Program
    {
        static void Main(string[] args)
        {   
            Hashtable myHash=new Hashtable();
            
            //插入
            myHash.Add("1","joye.net");
            myHash.Add("2", "joye.net2");
            myHash.Add("3", "joye.net3");

            //key 存在
            try
            {
                myHash.Add("1", "1joye.net");
            }
            catch
            {
                Console.WriteLine("Key = \"1\" already exists.");
            }
            //取值
            Console.WriteLine("key = \"2\", value = {0}.", myHash["2"]);

            //修改
            myHash["2"] = "http://www.cnblogs.com/yinrq/";
            myHash["4"] = "joye.net4";   //修改的key不存在則新增
            Console.WriteLine("key = \"2\", value = {0}.", myHash["2"]);
            Console.WriteLine("key = \"4\", value = {0}.", myHash["4"]);

            //判斷key是否存在
            if (!myHash.ContainsKey("5"))
            {
                myHash.Add("5", "joye.net5");
                Console.WriteLine("key = \"5\": {0}", myHash["5"]);
            }
             //移除
            myHash.Remove("1");

            if (!myHash.ContainsKey("1"))
            {
                Console.WriteLine("Key \"1\" is not found.");
            }
            //foreach 取值
            foreach (DictionaryEntry item in myHash)
            {
                Console.WriteLine("Key = {0}, Value = {1}", item.Key, item.Value);
            }
            //全部的值
            foreach (var item in myHash.Values)
            {
                Console.WriteLine("Value = {0}",item);
            }

            //全部的key
            foreach (var item in myHash.Keys)
            {
                Console.WriteLine("Key = {0}", item);
            }
            Console.ReadKey();
        }
    }
}

結果以下：

更多參考微軟官方文檔：Hashtable 類

2、Dictionary

Dictionary<TKey, TValue> 泛型類提供了從一組鍵到一組值的映射。經過鍵來檢索值的速度是很是快的，接近於 O(1)，這是由於 Dictionary<TKey, TValue> 類是做爲一個哈希表來實現的。檢索速度取決於爲 TKey 指定的類型的哈希算法的質量。TValue能夠是值類型，數組，類或其餘。

Dictionary是一種變種的HashTable,它採用一種分離連接散列表的數據結構來解決哈希衝突的問題。

簡單使用代碼：

using System;
using System.Collections;
using System.Collections.Generic;

namespace WebApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string, string> myDic = new Dictionary<string, string>();
            
            //插入
            myDic.Add("1", "joye.net");
            myDic.Add("2", "joye.net2");
            myDic.Add("3", "joye.net3");

            //key 存在
            try
            {
                myDic.Add("1", "1joye.net");
            }
            catch
            {
                Console.WriteLine("Key = \"1\" already exists.");
            }
            //取值
            Console.WriteLine("key = \"2\", value = {0}.", myDic["2"]);

            //修改
            myDic["2"] = "http://www.cnblogs.com/yinrq/";
            myDic["4"] = "joye.net4";   //修改的key不存在則新增
            Console.WriteLine("key = \"2\", value = {0}.", myDic["2"]);
            Console.WriteLine("key = \"4\", value = {0}.", myDic["4"]);

            //判斷key是否存在
            if (!myDic.ContainsKey("5"))
            {
                myDic.Add("5", "joye.net5");
                Console.WriteLine("key = \"5\": {0}", myDic["5"]);
            }
             //移除
            myDic.Remove("1");

            if (!myDic.ContainsKey("1"))
            {
                Console.WriteLine("Key \"1\" is not found.");
            }
            //foreach 取值
            foreach (var item in myDic)
            {
                Console.WriteLine("Key = {0}, Value = {1}", item.Key, item.Value);
            }
            //全部的值
            foreach (var item in myDic.Values)
            {
                Console.WriteLine("Value = {0}",item);
            }

            //全部的key
            foreach (var item in myDic.Keys)
            {
                Console.WriteLine("Key = {0}", item);
            }
            Console.ReadKey();
        }
    }
}

運行結果：

更多資料參考：Dictionary 類

3、ConcurrentDictionary

表示可由多個線程同時訪問的鍵/值對的線程安全集合。

ConcurrentDictionary<TKey, TValue> framework4出現的，可由多個線程同時訪問，且線程安全。用法同Dictionary不少相同，可是多了一些方法。ConcurrentDictionary 屬於System.Collections.Concurrent 命名空間按照MSDN上所說：

System.Collections.Concurrent 命名空間提供多個線程安全集合類。當有多個線程併發訪問集合時，應使用這些類代替 System.Collections 和 System.Collections.Generic 命名空間中的對應類型。

更多資料：ConcurrentDictionary<TKey,?TValue> 類

 

4、對比總結

分別插入500萬條數據，而後遍歷，看看耗時。

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;

namespace WebApp
{
    class Program
    {
        static Hashtable _hashtable;
        static Dictionary<string, string> _dictionary;
        static ConcurrentDictionary<string, string> _conDictionary;
        static void Main(string[] args)
        {
            Compare(5000000);
            Console.ReadLine();
            Console.Read();
        }

        public static void Compare(int dataCount)
        {
            _hashtable = new Hashtable();
            _dictionary = new Dictionary<string, string>();
            _conDictionary=new ConcurrentDictionary<string, string>();
            Stopwatch stopWatch = new Stopwatch();

            // Hashtable
            stopWatch.Start();
            for (int i = 0; i < dataCount; i++)
            {
                _hashtable.Add("key" + i.ToString(), "Value" + i.ToString());
            }
            stopWatch.Stop();
            Console.WriteLine("HashTable插" + dataCount + "條耗時(毫秒)：" + stopWatch.ElapsedMilliseconds);

            //Dictionary
            stopWatch.Reset();
            stopWatch.Start();
            for (int i = 0; i < dataCount; i++)
            {
                _dictionary.Add("key" + i.ToString(), "Value" +i.ToString());
            }
            stopWatch.Stop();
            Console.WriteLine("Dictionary插" + dataCount + "條耗時(毫秒)：" + stopWatch.ElapsedMilliseconds);

            //ConcurrentDictionary
            stopWatch.Reset();
            stopWatch.Start();
            for (int i = 0; i < dataCount; i++)
            {
                _conDictionary.TryAdd("key" + i.ToString(), "Value" + i.ToString());
            }
            stopWatch.Stop();
            Console.WriteLine("ConcurrentDictionary插" + dataCount + "條耗時(毫秒)：" + stopWatch.ElapsedMilliseconds);

            // Hashtable
            stopWatch.Reset();
            stopWatch.Start();
            for (int i = 0; i < _hashtable.Count; i++)
            {
                var key = _hashtable[i];
            }
            stopWatch.Stop();
            Console.WriteLine("HashTable遍歷時間(毫秒)：" + stopWatch.ElapsedMilliseconds);

            //Dictionary
            stopWatch.Reset();
            stopWatch.Start();
            for (int i = 0; i < _hashtable.Count; i++)
            {
                var key = _dictionary["key" + i.ToString()];
            }
            stopWatch.Stop();
            Console.WriteLine("Dictionary遍歷時間(毫秒)：" + stopWatch.ElapsedMilliseconds);

            //ConcurrentDictionary
            stopWatch.Reset();
            stopWatch.Start();
            for (int i = 0; i < _hashtable.Count; i++)
            {
                var key = _conDictionary["key"+i.ToString()];
            }
            stopWatch.Stop();
            Console.WriteLine("ConcurrentDictionary遍歷時間(毫秒)：" + stopWatch.ElapsedMilliseconds);
        }
    }
}

運行結果：

能夠看出：

大數據插入Dictionary花費時間最少

遍歷HashTable最快是Dictionary的1/5,ConcurrentDictionary的1/10

單線程建議用Dictionary，多線程建議用ConcurrentDictionary或者HashTable（Hashtable tab = Hashtable.Synchronized(new Hashtable());得到線程安全的對象）