.Net5 下Dictionary 為什麼可以在foreach中Remove

　　在一個討論群裡，看見有人說Dictionary可以在foreach中直接呼叫Remove了，帶著疑問，寫了簡單程式碼進行嘗試

　　

class Program
    {
        static void Main(string[] args)
        {

            var dic = Enumerable.Range(1, 10).ToDictionary(t => t, t => t);
            foreach (var i in dic)
            {
                if (i.Key.GetHashCode() % 2 == 0)
                {
                    dic.Remove(i.Key);
                }
                else
                {
                    Console.WriteLine($"{i.Key}");
                }
            }
            Console.WriteLine("Hello World!");
        }
    }

　　執行果然沒有報錯，輸出正常。

　　

 

　　終於不再需要進行單獨執行Remove

 

　　要想知道為啥在.Net Framework上不行，在.Net5下卻可以，就需要知道在.Net5中Dictionary有著什麼樣的變化

　　.Net Framework中原始碼         .Net5中原始碼

       我們看下兩者有什麼區別：

　　Framework中是這樣的：

　　

public bool MoveNext() {
                if (version != dictionary.version) {
                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
                }
 
                // Use unsigned comparison since we set index to dictionary.count+1 when the enumeration ends.
                // dictionary.count+1 could be negative if dictionary.count is Int32.MaxValue
                while ((uint)index < (uint)dictionary.count) {
                    if (dictionary.entries[index].hashCode >= 0) {
                        current = new KeyValuePair<TKey, TValue>(dictionary.entries[index].key, dictionary.entries[index].value);
                        index++;
                        return true;
                    }
                    index++;
                }
 
                index = dictionary.count + 1;
                current = new KeyValuePair<TKey, TValue>();
                return false;
            }

　　

　　.Net5中是這樣的：

　　

public bool MoveNext()
            {
                if (_version != _dictionary._version)
                {
                    ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
                }

                // Use unsigned comparison since we set index to dictionary.count+1 when the enumeration ends.
                // dictionary.count+1 could be negative if dictionary.count is int.MaxValue
                while ((uint)_index < (uint)_dictionary._count)
                {
                    ref Entry entry = ref _dictionary._entries![_index++];

                    if (entry.next >= -1)
                    {
                        _current = new KeyValuePair<TKey, TValue>(entry.key, entry.value);
                        return true;
                    }
                }

                _index = _dictionary._count + 1;
                _current = default;
                retur

 

　　細看好像兩者並沒什麼很明顯的區別。我們知道，在對Dictionary進行操作的時候，_version會自增改變，從而導致報錯。難道.Net5中進行Remove操作_version不會改變。

　　.Net5中Remove程式碼：

　　

public bool Remove(TKey key)
        {
            // The overload Remove(TKey key, out TValue value) is a copy of this method with one additional
            // statement to copy the value for entry being removed into the output parameter.
            // Code has been intentionally duplicated for performance reasons.

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

            if (_buckets != null)
            {
                Debug.Assert(_entries != null, "entries should be non-null");
                uint collisionCount = 0;
                uint hashCode = (uint)(_comparer?.GetHashCode(key) ?? key.GetHashCode());
                ref int bucket = ref GetBucket(hashCode);
                Entry[]? entries = _entries;
                int last = -1;
                int i = bucket - 1; // Value in buckets is 1-based
                while (i >= 0)
                {
                    ref Entry entry = ref entries[i];

                    if (entry.hashCode == hashCode && (_comparer?.Equals(entry.key, key) ?? EqualityComparer<TKey>.Default.Equals(entry.key, key)))
                    {
                        if (last < 0)
                        {
                            bucket = entry.next + 1; // Value in buckets is 1-based
                        }
                        else
                        {
                            entries[last].next = entry.next;
                        }

                        Debug.Assert((StartOfFreeList - _freeList) < 0, "shouldn't underflow because max hashtable length is MaxPrimeArrayLength = 0x7FEFFFFD(2146435069) _freelist underflow threshold 2147483646");
                        entry.next = StartOfFreeList - _freeList;

                        if (RuntimeHelpers.IsReferenceOrContainsReferences<TKey>())
                        {
                            entry.key = default!;
                        }

                        if (RuntimeHelpers.IsReferenceOrContainsReferences<TValue>())
                        {
                            entry.value = default!;
                        }

                        _freeList = i;
                        _freeCount++;
                        return true;
                    }

                    last = i;
                    i = entry.next;

                    collisionCount++;
                    if (collisionCount > (uint)entries.Length)
                    {
                        // The chain of entries forms a loop; which means a concurrent update has happened.
                        // Break out of the loop and throw, rather than looping forever.
                        ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
                    }
                }
            }
            return false;
        }

　　一看果然_version不會變化。看到這可能會直呼內行啊，一行程式碼就解決問題，那為什麼Framework中不這樣做呢。相關提交討論