private int[]? _buckets; // _entries索引數(shù)組
private Entry[]? _entries; // 實(shí)體數(shù)組

private int _count; // 實(shí)際存儲(chǔ)的元素?cái)?shù)量
private int _freeList; // 空位鏈表頭索引，初始值-1
private int _freeCount; // 空位數(shù)量
private struct Entry
{
    public int HashCode;
    public int Next;
    public T Value;
}
public int Count => _count - _freeCount; // _count不會(huì)記錄被刪除的元素，因此實(shí)際元素?cái)?shù)量為_(kāi)count - _freeCount

private int Initialize(int capacity)
{
    int size = HashHelpers.GetPrime(capacity); // 獲取>=capacity的最小素?cái)?shù)
    var buckets = new int[size];
    var entries = new Entry[size];
    // ...
    return size;
}

private int FindItemIndex(T item)
{
    // ...
    int hashCode = item != null ? item.GetHashCode() : 0;
    if (typeof(T).IsValueType)
    {
        int i = GetBucketRef(hashCode) - 1; // _buckets元素從1開(kāi)始
        while (i >= 0) // 存在與item相同的哈希值，不一定存在item
        {
            ref Entry entry = ref entries[i];
            if (entry.HashCode == hashCode && EqualityComparer<T>.Default.Equals(entry.Value, item))
            {
                return i; // HashCode相等且元素相等，則查找到元素，返回_entries索引
            }
            i = entry.Next;

            collisionCount++;
            // ...
        }
    }
    // ...
    return -1;
}

private ref int GetBucketRef(int hashCode)
{
    int[] buckets = _buckets!;
    return ref buckets[(uint)hashCode % (uint)buckets.Length]; // 使用除留余數(shù)法構(gòu)造哈希函數(shù)
}

private bool AddIfNotPresent(T value, out int location)
{
    bucket = ref GetBucketRef(hashCode); // bucket為ref int類(lèi)型，若不存在沖突，bucket應(yīng)為0，因?yàn)閕nt默認(rèn)值為0
    // ...

    int index;
    if (_freeCount > 0) // 存在刪除后的空位，將元素放在空位上
    {
        index = _freeList;
        _freeCount--; // 更新刪除后空位數(shù)量
        _freeList = StartOfFreeList - entries[_freeList].Next; // 更新空位索引
    }
    else // 按_entries順序存儲(chǔ)元素
    {
        int count = _count;
        if (count == entries.Length) // 容量不足，擴(kuò)容
        {
            Resize();
            bucket = ref GetBucketRef(hashCode);
        }
        index = count;
        _count = count + 1;
        entries = _entries;
    }

    {   // 賦值
        ref Entry entry = ref entries![index];
        entry.HashCode = hashCode;
        entry.Next = bucket - 1; // 若不存在沖突則為-1，否則形成鏈表，指向沖突的下一元素索引
        entry.Value = value;
        bucket = index + 1; // 此處對(duì)bucket賦值，即改變_buckets對(duì)應(yīng)元素，即將以插入元素哈希值為索引的_buckets值指向存放插入元素的_entries的索引+1
        _version++;
        location = index;
    }

    // ...
    return true;
}

private void Resize() => Resize(HashHelpers.ExpandPrime(_count), forceNewHashCodes: false);

public static int ExpandPrime(int oldSize)
{
    int num = 2 * oldSize;
    if ((uint)num > 2146435069u && 2146435069 > oldSize)
    {
        return 2146435069;
    }

    return GetPrime(num); // 返回原大小2倍的最小素?cái)?shù)
}

private void Resize(int newSize, bool forceNewHashCodes)
{
    var entries = new Entry[newSize];
    Array.Copy(_entries, entries, count);
    // ...

    _buckets = new int[newSize];
    for (int i = 0; i < count; i++)
    {
        ref Entry entry = ref entries[i];
        if (entry.Next >= -1) // 更新_buckets內(nèi)容
        {
            ref int bucket = ref GetBucketRef(entry.HashCode); // 獲取以新大小作為除數(shù)的哈希函數(shù)運(yùn)算得到的哈希值
            entry.Next = bucket - 1; // 更新Next
            bucket = i + 1; // 更新_buckets的元素，指向重新計(jì)算的_entry索引+1
        }
    }

    _entries = entries;
}

public bool Remove(T item)
{
    int last = -1;
    int hashCode = item != null ? (_comparer?.GetHashCode(item) ?? item.GetHashCode()) : 0;
    ref int bucket = ref GetBucketRef(hashCode);
    int i = bucket - 1;

    while (i >= 0)
    {
        ref Entry entry = ref entries[i];
        if (entry.HashCode == hashCode && (_comparer?.Equals(entry.Value, item) ?? EqualityComparer<T>.Default.Equals(entry.Value, item)))
        {
            // 找到待刪除元素
            if (last < 0) // 待刪除元素位于鏈表頭部，更新_buckets元素值指向鏈表下一位置
            {
                bucket = entry.Next + 1;
            }
            else // 待刪除元素非鏈表頭，需更新鏈表上一元素Next值
                entries[last].Next = entry.Next;
            entry.Next = StartOfFreeList - _freeList; // 空位鏈表，記錄下一空位索引相對(duì)位置，插入時(shí)根據(jù)該值更新_freeList
            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
                entry.Value = default!;
            _freeList = i; // 記錄刪除元素位置，下次插入元素時(shí)，會(huì)插入在此
            _freeCount++;  // 更新刪除后空位數(shù)量
            return true;
        }
        last = i; // 存在沖突，記錄鏈表上一位置
        i = entry.Next;
    }
    return false;
}