.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中不这样做呢。相关提交讨论