Unity Dictionary底层源码剖析

---

前言

Dictionary字典型数据结构本质是关键字Key值和Value值一一映射的关系。Key可以是不同的类型，int、string等等，怎么挥事呢？答案是哈希表，是利用哈希函数将键映射到特定位置，以实现快速的键值检索。

砖家建议：先看List源码解析，再看本章。

---

一、Dictionary源码

变量的定义部分：

public class Dictionary<TKey,TValue>: IDictionary<TKey,TValue>, IDictionary, 
    IReadOnlyDictionary<TKey, TValue>, ISerializable, IDeserializationCallback
{

    private struct Entry {
        public int hashCode;            // 低31位为Hash值，如果未使用则为-1
        public int next;                // 下一个实例索引，如果是最后一个则为-1
        public TKey key;                // 实例的键值
        public TValue value;            // 实例的值
    }

    private int[] buckets;
    private Entry[] entries;
    private int count;
    private int version;
    private int freeList;
    private int freeCount;
    private IEqualityComparer<TKey>comparer;
    private KeyCollection keys;
    private ValueCollection values;
    private Object _syncRoot;
}

Dictionary主要继承了IDictionary接口和ISerializable接口。同时也能看出Dictionary数据结构中和List一样，都是以数组为底层数据结构，所以猜测 扩容操作也是需要的。

Dictionary源码网址为：官方跳转链接

二、Add接口

接口源码如下：

public void Add(TKey key, TValue value)
{
    Insert(key, value, true);
}
private void Initialize(int capacity)
{
    int size = HashHelpers.GetPrime(capacity);
    buckets = new int[size];
    for (int i = 0; i<buckets.Length; i++) buckets[i] = -1;
    entries = new Entry[size];
    freeList = -1;
}

private void Insert(TKey key, TValue value, bool add)
{
    if( key == null) {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
    }

    if (buckets == null) Initialize(0);
    int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
    int targetBucket = hashCode % buckets.Length;

#if FEATURE_RANDOMIZED_STRING_HASHING
    int collisionCount = 0;
#endif

    for (int i = buckets[targetBucket]; i>= 0; i = entries[i].next) {
        if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].key, key)) {
            if (add) {
                ThrowHelper.ThrowArgumentException(
                    ExceptionResource.Argument_AddingDuplicate);
            }
            entries[i].value = value;
            version++;
            return;
        }

#if FEATURE_RANDOMIZED_STRING_HASHING
        collisionCount++;
#endif
    }
    int index;
    if (freeCount>0) {
        index = freeList;
        freeList = entries[index].next;
        freeCount--;
    }
    else {
        if (count == entries.Length)
        {
            Resize();
            targetBucket = hashCode % buckets.Length;
        }
        index = count;
        count++;
    }

    entries[index].hashCode = hashCode;
    entries[index].next = buckets[targetBucket];
    entries[index].key = key;
    entries[index].value = value;
    buckets[targetBucket] = index;
    version++;

#if FEATURE_RANDOMIZED_STRING_HASHING

#if FEATURE_CORECLR
    // 如果我们触碰到阈值，则需要切换到使用随机字符串Hash的比较器上
    // 在这种情况下，将是EqualityComparer<string>.Default
    // 注意，默认情况下，coreclr上的随机字符串Hash是打开的，所以EqualityComparer<string>.
Default将使用随机字符串Hash

    if (collisionCount>HashHelpers.HashCollisionThreshold && comparer ==
        NonRandomizedStringEqualityComparer.Default)
    {
        comparer = (IEqualityComparer<TKey>) EqualityComparer<string>.Default;
        Resize(entries.Length, true);
    }
#else
    if(collisionCount>HashHelpers.HashCollisionThreshold &&
        HashHelpers.IsWellKnownEqualityComparer(comparer))
    {
        comparer = (IEqualityComparer<TKey>)
            HashHelpers.GetRandomizedEqualityComparer(comparer);
        Resize(entries.Length, true);
    }
#endif // FEATURE_CORECLR

#endif

}

代码很多，简单的分析关键点。首先，Add是由Insert方法代理，加入之前判空后进行数据构造。

if( key == null) {//判空
    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
}

 if (buckets == null) Initialize(0);//buchets出事为空数组，对其初始化

我们继续看Initialize方法。里面写了如何初始化的，这个和List有点差别，研究一下，发现primes数值是质数。

 int size = HashHelpers.GetPrime(capacity);

HashHelpers，primes数值

public static readonly int[] primes = {
        3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 
            293, 353, 431, 521, 631, 761, 919,
        1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 
            8419, 10103, 12143, 14591,
        17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 
            108631, 130363, 156437,
        187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 
            807403, 968897, 1162687, 1395263,
        1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 
            7199369
};

如果超出这个界限呢，那就返回之前的2倍。如果你创建字典时指定了初始大小，会计算成应该分配的大小。

public static int GetPrime(int min)
{
    if (min<0)
        throw new ArgumentException(
            Environment.GetResourceString("Arg_HTCapacityOverflow"));
    Contract.EndContractBlock();

    for (int i = 0; i<primes.Length; i++)
    {
        int prime = primes[i];
        if (prime>= min) return prime;
    }

    // 如果在我们的预定义表之外，则做硬计算
    for (int i = (min | 1); i<Int32.MaxValue;i+=2)
    {
        if (IsPrime(i) && ((i - 1) % Hashtable.HashPrime != 0))
            return i;
    }
    return min;
}

// 返回要增长到的Hash表的大小
public static int ExpandPrime(int oldSize)
{
    int newSize = 2 * oldSize;

    // 在遇到容量溢出之前，允许Hash表增长到最大可能的大小（约2G个元素）
    // 请注意，即使（item.Length）由于（uint）强制转换而溢出，此检查仍然有效
    if ((uint)newSize>MaxPrimeArrayLength && MaxPrimeArrayLength>oldSize)
    {
        Contract.Assert( MaxPrimeArrayLength == GetPrime(MaxPrimeArrayLength),
            "Invalid MaxPrimeArrayLength");
        return MaxPrimeArrayLength;
    }

    return GetPrime(newSize);
}

初始化之后，对key进行hash处理，得到地址索引。

 int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
 int targetBucket = hashCode % buckets.Length;//取余，确保索引地址在数组长度范围内，否则可能溢出

然后对指定的数组单元格内的链表进行遍历，提取空位置将值填入。拉链法（下有讲解）的链表推入操作。

for (int i = buckets[targetBucket]; i>= 0; i = entries[i].next) {
    if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].key, key)) {
        if (add) {
            ThrowHelper.ThrowArgumentException(
                ExceptionResource.Argument_AddingDuplicate);
        }
        entries[i].value = value;
        version++;
        return;
    }

#if FEATURE_RANDOMIZED_STRING_HASHING
    collisionCount++;
#endif
}

拉链法是一种解决哈希冲突的方法，主要应用在哈希表中。当不同的关键字经过哈希函数计算后得到相同的哈希地址时，就产生了哈希冲突。拉链法解决冲突的做法是：将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数组T[0…m-1]。凡是散列地址为i的结点，均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。

如果数组空间不够，也就是代码中freeCount=0时的逻辑进行扩容，扩容后的大小为计算过的大小，通常为之前的2倍。（参考ExpandPrime方法）

 int index;
    if (freeCount>0) {
        index = freeList;
        freeList = entries[index].next;
        freeCount--;
    }
    else {
        if (count == entries.Length)
        {
            Resize();
            targetBucket = hashCode % buckets.Length;
        }
        index = count;
        count++;
    }

    entries[index].hashCode = hashCode;
    entries[index].next = buckets[targetBucket];
    entries[index].key = key;
    entries[index].value = value;
    buckets[targetBucket] = index;

三、Remove接口

接口源码如下：

public bool Remove(TKey key)
{
    if(key == null) {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
    }

    if (buckets != null) {
        int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
        int bucket = hashCode % buckets.Length;
        int last = -1;
        for (int i = buckets[bucket]; i>= 0; last = i, i = entries[i].next) {
            if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].
                key, key)) {
                if (last<0) {
                    buckets[bucket] = entries[i].next;
                }
                else {
                    entries[last].next = entries[i].next;
                }
                entries[i].hashCode = -1;
                entries[i].next = freeList;
                entries[i].key = default(TKey);
                entries[i].value = default(TValue);
                freeList = i;
                freeCount++;
                version++;
                return true;
            }
        }
    }
    return false;
}

移除的原理和Add一样利用了Hash值，再进行余操作，确认索引在数组范围内后，遍历地址进行查找，key值相同则进行移除操作。但是这里为了减少内存频繁操作，直接进行置空。

四、ContainsKey接口

接口源码如下：

public bool ContainsKey(TKey key)
{
    return FindEntry(key)>= 0;
}

private int FindEntry(TKey key)
{
    if( key == null) {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
    }

    if (buckets != null) {
        int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
        for (int i = buckets[hashCode % buckets.Length]; i>= 0; i = 
            entries[i].next) {
            if (entries[i].hashCode ==
                hashCode && comparer.Equals(entries[i].key,key)) return i;
        }
    }
    return -1;
}

这个方法的作用是在哈希表中查找指定键的位置，如果找到则返回该键所在的索引，如果未找到则返回 -1。和Remove的查找方式类似，查找所有冲突列表中与key相当的值。

五、TryGetValue接口

接口源码如下：

public bool TryGetValue(TKey key, out TValue value)
{
    int i = FindEntry(key);
    if (i>= 0) {
        value = entries[i].value;
        return true;
    }
    value = default(TValue);
    return false;
}

TryGetValue接口调用FindEntry方法，其中TValue是对[]操作符的重定义。而TValue中又调用了Insert。

public TValue this[TKey key] {
    get {
        int i = FindEntry(key);
        if (i>= 0) return entries[i].value;
        ThrowHelper.ThrowKeyNotFoundException();
        return default(TValue);
    }
    set {
        Insert(key, value, false);
    }
}

六、哈希函数

综上所述，可以看出哈希冲突的拉链法贯穿了其底层数据结构。所以其中哈希函数决定了字典的效率。
以下是函数创建过程源码：

private static EqualityComparer<T>CreateComparer()
{
    Contract.Ensures(Contract.Result<EqualityComparer<T>>() != null);

    RuntimeType t = (RuntimeType)typeof(T);
    // 出于性能原因专门用字节类型
    if (t == typeof(byte)) {
        return (EqualityComparer<T>)(object)(new ByteEqualityComparer());
    }
    // 如果T implements IEquatable<T>返回一个GenericEqualityComparer<T>
    if (typeof(IEquatable<T>).IsAssignableFrom(t)) {
        return (EqualityComparer<T>)
            RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter(
            (RuntimeType)typeof(GenericEqualityComparer<int>), t);
    }
    // 如果T是一个Nullable<U>从U implements IEquatable<U>返回的NullableEquality
        Comparer<U>
    if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>)) {
        RuntimeType u = (RuntimeType)t.GetGenericArguments()[0];
        if (typeof(IEquatable<>).MakeGenericType(u).IsAssignableFrom(u)) {
            return (EqualityComparer<T>)
                RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((
                RuntimeType)typeof(NullableEqualityComparer<int>), u);
        }
    }

    // 看这个METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST和METHOD__JIT_HELPERS__UNSAFE_
ENUM_CAST_LONG在getILIntrinsicImplementation中的例子
    if (t.IsEnum) {
        TypeCode underlyingTypeCode = Type.GetTypeCode(
            Enum.GetUnderlyingType(t));

        // 根据枚举类型，我们需要对比较器进行特殊区分，以免装箱
        // 注意，我们要对Short和SByte使用不同的比较器，因为对于这些类型，
        // 我们需要确保在实际的基础类型上调用GetHashCode，其中，GetHashCode的实现比其他类型更复杂
        switch (underlyingTypeCode) {
            case TypeCode.Int16: 
                return (EqualityComparer<T>)
                RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((
                RuntimeType)typeof(ShortEnumEqualityComparer<short>), t);
            case TypeCode.SByte:
                return (EqualityComparer<T>)
                RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((
                RuntimeType)typeof(SByteEnumEqualityComparer<sbyte>), t);
            case TypeCode.Int32:
            case TypeCode.UInt32:
            case TypeCode.Byte:
            case TypeCode.UInt16: 
                return (EqualityComparer<T>)
                RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((
                RuntimeType)typeof(EnumEqualityComparer<int>), t);
            case TypeCode.Int64:
            case TypeCode.UInt64:
                return (EqualityComparer<T>)
                    RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((
                    RuntimeType)typeof(LongEnumEqualityComparer<long>), t);
        }
    }
    // 否则，返回一个ObjectEqualityComparer<T>
    return new ObjectEqualityComparer<T>();
}

源码中可以看到有四种处理方式，分别对应byte、IEquatable、IEquatable、underlyingTypeCode四种类型。其中byte和underlyingTypeCode，一个字节、一个数字，容易比较；有IEquatable接口的则使用GenericEqualityComparer获取哈希函数；对于IEquatable来说，如果有Nullable接口就使用NullableEqualityComparer
，如果没有直接使用默认的ObjectEqualityComparer。
项目中想优化，尽量使用数值方式作为键值对。其他方式的Hash值通常使用内存地址比较，消耗较大。

在C#中，所有类指向Object类，比较时没有重写Equals函数时，都是进行内存地址进行比较，消耗较大。

七、线程安全

最后提一点，Dictionary是线程同样是不安全的，需要加锁。但是Hashtable是线程安全的。

---

总结

Dictionary 是一种常见的数据结构，由数组构成，使用哈希函数将键映射到数组的特定位置。它通过哈希表实现键值对的存储和检索，具有快速的查找、插入和删除操作。在解决哈希冲突方面，Dictionary 使用了拉链法，将具有相同哈希码的键值对存储在同一个链表中，从而保证了高效的冲突解决和性能表现。