Externalize Dictionary Rehash

Author: benaadams

src/mscorlib/shared/System/Collections/Generic/Dictionary.cs

@@ -37,21 +37,21 @@ internal enum InsertionBehavior : byte
     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>, ISerializable, IDeserializationCallback
     {
-        private struct Entry
+        internal struct Entry
         {
             public int hashCode;    // Lower 31 bits of hash code, -1 if unused
             public int next;        // Index of next entry, -1 if last
             public TKey key;           // Key of entry
             public TValue value;         // Value of entry
         }
 
-        private int[] _buckets;
-        private Entry[] _entries;
-        private int _count;
+        internal int[] _buckets;
+        internal Entry[] _entries;
+        internal int _count;
         private int _version;
         private int _freeList;
         private int _freeCount;
-        private IEqualityComparer<TKey> _comparer;
+        internal IEqualityComparer<TKey> _comparer;
         private KeyCollection _keys;
         private ValueCollection _values;
         private object _syncRoot;
@@ -440,13 +440,13 @@ private bool TryInsert(TKey key, TValue value, InsertionBehavior behavior)
             _buckets[targetBucket] = index;
             _version++;
 
-            // If we hit the collision threshold we'll need to switch to the comparer which is using randomized string hashing
-            // i.e. EqualityComparer<string>.Default.
 
             if (default(TKey) == null && collisionCount > HashHelpers.HashCollisionThreshold && _comparer is NonRandomizedStringEqualityComparer)
             {
+                // If we hit the collision threshold we'll need to switch to the comparer which is using randomized string hashing
+                // i.e. EqualityComparer<string>.Default.
                 _comparer = (IEqualityComparer<TKey>)EqualityComparer<string>.Default;
-                Rehash();
+                DictionaryHelper.Rehash((Dictionary<string, TValue>)(object)this);
             }
 
             return true;
@@ -498,35 +498,6 @@ public virtual void OnDeserialization(object sender)
             HashHelpers.SerializationInfoTable.Remove(this);
         }
 
-        private void Rehash()
-        {
-            int[] buckets = _buckets;
-            for (int i = 0; i < buckets.Length; i++)
-            {
-                buckets[i] = -1;
-            }
-
-            int count = _count;
-            int length = buckets.Length;
-            Entry[] entries = _entries;
-
-            IEqualityComparer<TKey> comparer = _comparer;
-
-            for (int i = 0; i < count; i++)
-            {
-                ref Entry entry = ref entries[i];
-                int hashCode = entry.hashCode;
-                if (hashCode >= 0)
-                {
-                    hashCode = (comparer.GetHashCode(entry.key) & 0x7FFFFFFF);
-                    int bucket = hashCode % length;
-                    entry.hashCode = hashCode;
-                    entry.next = buckets[bucket];
-                    buckets[bucket] = i;
-                }
-            }
-        }
-
         private void Expand(int prime)
         {
             Debug.Assert(HashHelpers.IsPrime(prime));
@@ -1485,4 +1456,39 @@ void System.Collections.IEnumerator.Reset()
             }
         }
     }
+
+    internal class DictionaryHelper
+    {
+        internal static void Rehash<TValue>(Dictionary<string, TValue> dict)
+        {
+            // Rehash is externalised for string keys only; rather than an instance method
+            // so it isn't compiled into every generic instance type for AOT compiles
+
+            int[] buckets = dict._buckets;
+            for (int i = 0; i < buckets.Length; i++)
+            {
+                buckets[i] = -1;
+            }
+
+            int count = dict._count;
+            int length = buckets.Length;
+            Dictionary<string, TValue>.Entry[] entries = dict._entries;
+
+            IEqualityComparer<string> comparer = dict._comparer;
+
+            for (int i = 0; i < count; i++)
+            {
+                ref Dictionary<string, TValue>.Entry entry = ref entries[i];
+                int hashCode = entry.hashCode;
+                if (hashCode >= 0)
+                {
+                    hashCode = (comparer.GetHashCode(entry.key) & 0x7FFFFFFF);
+                    int bucket = hashCode % length;
+                    entry.hashCode = hashCode;
+                    entry.next = buckets[bucket];
+                    buckets[bucket] = i;
+                }
+            }
+        }
+    }
 }