Imported Upstream version 2.0.0.11353upstream/2.0.0.11353

1 files changed, 690 insertions, 370 deletions

diff --git a/src/mscorlib/src/System/Collections/Generic/Dictionary.cs b/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
index 7b60e31031..409b23b541 100644
--- a/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
+++ b/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
@@ -41,20 +41,43 @@
 **       to serialization such that this code doesn't need to build in 
 **       silverlight. 
 ===========================================================*/
-namespace System.Collections.Generic {
 
+namespace System.Collections.Generic
+{
     using System;
     using System.Collections;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.Runtime.Serialization;
 
+    /// <summary>
+    /// Used internally to control behavior of insertion into a <see cref="Dictionary{TKey, TValue}"/>.
+    /// </summary>
+    internal enum InsertionBehavior : byte
+    {
+        /// <summary>
+        /// The default insertion behavior.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Specifies that an existing entry with the same key should be overwritten if encountered.
+        /// </summary>
+        OverwriteExisting = 1,
+
+        /// <summary>
+        /// Specifies that if an existing entry with the same key is encountered, an exception should be thrown.
+        /// </summary>
+        ThrowOnExisting = 2
+    }
+
     [DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]
     [DebuggerDisplay("Count = {Count}")]
     [Serializable]
-    public class Dictionary<TKey,TValue>: IDictionary<TKey,TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>, ISerializable, IDeserializationCallback  {
-    
-        private struct Entry {
+    public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>, ISerializable, IDeserializationCallback
+    {
+        private 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
@@ -71,38 +94,40 @@ namespace System.Collections.Generic {
         private KeyCollection keys;
         private ValueCollection values;
         private Object _syncRoot;
-        
+
         // constants for serialization
         private const String VersionName = "Version";
         private const String HashSizeName = "HashSize";  // Must save buckets.Length
         private const String KeyValuePairsName = "KeyValuePairs";
         private const String ComparerName = "Comparer";
 
-        public Dictionary(): this(0, null) {}
+        public Dictionary() : this(0, null) { }
 
-        public Dictionary(int capacity): this(capacity, null) {}
+        public Dictionary(int capacity) : this(capacity, null) { }
 
-        public Dictionary(IEqualityComparer<TKey> comparer): this(0, comparer) {}
+        public Dictionary(IEqualityComparer<TKey> comparer) : this(0, comparer) { }
 
-        public Dictionary(int capacity, IEqualityComparer<TKey> comparer) {
+        public Dictionary(int capacity, IEqualityComparer<TKey> comparer)
+        {
             if (capacity < 0) ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
             if (capacity > 0) Initialize(capacity);
             this.comparer = comparer ?? EqualityComparer<TKey>.Default;
 
 #if FEATURE_RANDOMIZED_STRING_HASHING
-            if (HashHelpers.s_UseRandomizedStringHashing && comparer == EqualityComparer<string>.Default)
+            if (HashHelpers.s_UseRandomizedStringHashing && this.comparer == EqualityComparer<string>.Default)
             {
-                this.comparer = (IEqualityComparer<TKey>) NonRandomizedStringEqualityComparer.Default;
+                this.comparer = (IEqualityComparer<TKey>)NonRandomizedStringEqualityComparer.Default;
             }
 #endif // FEATURE_RANDOMIZED_STRING_HASHING
         }
 
-        public Dictionary(IDictionary<TKey,TValue> dictionary): this(dictionary, null) {}
-
-        public Dictionary(IDictionary<TKey,TValue> dictionary, IEqualityComparer<TKey> comparer):
-            this(dictionary != null? dictionary.Count: 0, comparer) {
+        public Dictionary(IDictionary<TKey, TValue> dictionary) : this(dictionary, null) { }
 
-            if( dictionary == null) {
+        public Dictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) :
+            this(dictionary != null ? dictionary.Count : 0, comparer)
+        {
+            if (dictionary == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
             }
 
@@ -110,138 +135,174 @@ namespace System.Collections.Generic {
             // avoid the enumerator allocation and overhead by looping through the entries array directly.
             // We only do this when dictionary is Dictionary<TKey,TValue> and not a subclass, to maintain
             // back-compat with subclasses that may have overridden the enumerator behavior.
-            if (dictionary.GetType() == typeof(Dictionary<TKey,TValue>)) {
-                Dictionary<TKey,TValue> d = (Dictionary<TKey,TValue>)dictionary;
+            if (dictionary.GetType() == typeof(Dictionary<TKey, TValue>))
+            {
+                Dictionary<TKey, TValue> d = (Dictionary<TKey, TValue>)dictionary;
                 int count = d.count;
                 Entry[] entries = d.entries;
-                for (int i = 0; i < count; i++) {
-                    if (entries[i].hashCode >= 0) {
+                for (int i = 0; i < count; i++)
+                {
+                    if (entries[i].hashCode >= 0)
+                    {
                         Add(entries[i].key, entries[i].value);
                     }
                 }
                 return;
             }
 
-            foreach (KeyValuePair<TKey,TValue> pair in dictionary) {
+            foreach (KeyValuePair<TKey, TValue> pair in dictionary)
+            {
                 Add(pair.Key, pair.Value);
             }
         }
 
-        public Dictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection):
-            this(collection, null) { }
+        public Dictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection) :
+            this(collection, null)
+        { }
 
-        public Dictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer):
+        public Dictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer) :
             this((collection as ICollection<KeyValuePair<TKey, TValue>>)?.Count ?? 0, comparer)
         {
-            if (collection == null) {
+            if (collection == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
             }
 
-            foreach (KeyValuePair<TKey, TValue> pair in collection) {
+            foreach (KeyValuePair<TKey, TValue> pair in collection)
+            {
                 Add(pair.Key, pair.Value);
             }
         }
 
-        protected Dictionary(SerializationInfo info, StreamingContext context) {
+        protected Dictionary(SerializationInfo info, StreamingContext context)
+        {
             //We can't do anything with the keys and values until the entire graph has been deserialized
             //and we have a resonable estimate that GetHashCode is not going to fail.  For the time being,
             //we'll just cache this.  The graph is not valid until OnDeserialization has been called.
             HashHelpers.SerializationInfoTable.Add(this, info);
         }
-            
-        public IEqualityComparer<TKey> Comparer {
-            get {
-                return comparer;                
-            }               
+
+        public IEqualityComparer<TKey> Comparer
+        {
+            get
+            {
+                return comparer;
+            }
         }
-        
-        public int Count {
+
+        public int Count
+        {
             get { return count - freeCount; }
         }
 
-        public KeyCollection Keys {
-            get {
+        public KeyCollection Keys
+        {
+            get
+            {
                 Contract.Ensures(Contract.Result<KeyCollection>() != null);
                 if (keys == null) keys = new KeyCollection(this);
                 return keys;
             }
         }
 
-        ICollection<TKey> IDictionary<TKey, TValue>.Keys {
-            get {                
-                if (keys == null) keys = new KeyCollection(this);                
+        ICollection<TKey> IDictionary<TKey, TValue>.Keys
+        {
+            get
+            {
+                if (keys == null) keys = new KeyCollection(this);
                 return keys;
             }
         }
 
-        IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys {
-            get {                
-                if (keys == null) keys = new KeyCollection(this);                
+        IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys
+        {
+            get
+            {
+                if (keys == null) keys = new KeyCollection(this);
                 return keys;
             }
         }
 
-        public ValueCollection Values {
-            get {
+        public ValueCollection Values
+        {
+            get
+            {
                 Contract.Ensures(Contract.Result<ValueCollection>() != null);
                 if (values == null) values = new ValueCollection(this);
                 return values;
             }
         }
 
-        ICollection<TValue> IDictionary<TKey, TValue>.Values {
-            get {                
+        ICollection<TValue> IDictionary<TKey, TValue>.Values
+        {
+            get
+            {
                 if (values == null) values = new ValueCollection(this);
                 return values;
             }
         }
 
-        IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values {
-            get {                
+        IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values
+        {
+            get
+            {
                 if (values == null) values = new ValueCollection(this);
                 return values;
             }
         }
 
-        public TValue this[TKey key] {
-            get {
+        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);
+            set
+            {
+                bool modified = TryInsert(key, value, InsertionBehavior.OverwriteExisting);
+                Debug.Assert(modified);
             }
         }
 
-        public void Add(TKey key, TValue value) {
-            Insert(key, value, true);
+        public void Add(TKey key, TValue value)
+        {
+            bool modified = TryInsert(key, value, InsertionBehavior.ThrowOnExisting);
+            Debug.Assert(modified); // If there was an existing key and the Add failed, an exception will already have been thrown.
         }
 
-        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair) {
+        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair)
+        {
             Add(keyValuePair.Key, keyValuePair.Value);
         }
 
-        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair) {
+        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair)
+        {
             int i = FindEntry(keyValuePair.Key);
-            if( i >= 0 && EqualityComparer<TValue>.Default.Equals(entries[i].value, keyValuePair.Value)) {
+            if (i >= 0 && EqualityComparer<TValue>.Default.Equals(entries[i].value, keyValuePair.Value))
+            {
                 return true;
             }
             return false;
         }
 
-        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair) {
+        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair)
+        {
             int i = FindEntry(keyValuePair.Key);
-            if( i >= 0 && EqualityComparer<TValue>.Default.Equals(entries[i].value, keyValuePair.Value)) {
+            if (i >= 0 && EqualityComparer<TValue>.Default.Equals(entries[i].value, keyValuePair.Value))
+            {
                 Remove(keyValuePair.Key);
                 return true;
             }
             return false;
         }
 
-        public void Clear() {
-            if (count > 0) {
+        public void Clear()
+        {
+            if (count > 0)
+            {
                 for (int i = 0; i < buckets.Length; i++) buckets[i] = -1;
                 Array.Clear(entries, 0, count);
                 freeList = -1;
@@ -251,90 +312,106 @@ namespace System.Collections.Generic {
             }
         }
 
-        public bool ContainsKey(TKey key) {
+        public bool ContainsKey(TKey key)
+        {
             return FindEntry(key) >= 0;
         }
 
-        public bool ContainsValue(TValue value) {
-            if (value == null) {
-                for (int i = 0; i < count; i++) {
+        public bool ContainsValue(TValue value)
+        {
+            if (value == null)
+            {
+                for (int i = 0; i < count; i++)
+                {
                     if (entries[i].hashCode >= 0 && entries[i].value == null) return true;
                 }
             }
-            else {
+            else
+            {
                 EqualityComparer<TValue> c = EqualityComparer<TValue>.Default;
-                for (int i = 0; i < count; i++) {
+                for (int i = 0; i < count; i++)
+                {
                     if (entries[i].hashCode >= 0 && c.Equals(entries[i].value, value)) return true;
                 }
             }
             return false;
         }
 
-        private void CopyTo(KeyValuePair<TKey,TValue>[] array, int index) {
-            if (array == null) {
+        private void CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
+        {
+            if (array == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
             }
-            
-            if (index < 0 || index > array.Length ) {
+
+            if (index < 0 || index > array.Length)
+            {
                 ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
             }
 
-            if (array.Length - index < Count) {
+            if (array.Length - index < Count)
+            {
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
             }
 
             int count = this.count;
             Entry[] entries = this.entries;
-            for (int i = 0; i < count; i++) {
-                if (entries[i].hashCode >= 0) {
-                    array[index++] = new KeyValuePair<TKey,TValue>(entries[i].key, entries[i].value);
+            for (int i = 0; i < count; i++)
+            {
+                if (entries[i].hashCode >= 0)
+                {
+                    array[index++] = new KeyValuePair<TKey, TValue>(entries[i].key, entries[i].value);
                 }
             }
         }
 
-        public Enumerator GetEnumerator() {
+        public Enumerator GetEnumerator()
+        {
             return new Enumerator(this, Enumerator.KeyValuePair);
         }
 
-        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator() {
+        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
+        {
             return new Enumerator(this, Enumerator.KeyValuePair);
-        }        
+        }
 
-        public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {
-            if (info==null) {
+        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            if (info == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.info);
             }
             info.AddValue(VersionName, version);
-
-#if FEATURE_RANDOMIZED_STRING_HASHING
-            info.AddValue(ComparerName, HashHelpers.GetEqualityComparerForSerialization(comparer), typeof(IEqualityComparer<TKey>));
-#else
             info.AddValue(ComparerName, comparer, typeof(IEqualityComparer<TKey>));
-#endif
-
             info.AddValue(HashSizeName, buckets == null ? 0 : buckets.Length); //This is the length of the bucket array.
-            if( buckets != null) {
+            if (buckets != null)
+            {
                 KeyValuePair<TKey, TValue>[] array = new KeyValuePair<TKey, TValue>[Count];
                 CopyTo(array, 0);
                 info.AddValue(KeyValuePairsName, array, typeof(KeyValuePair<TKey, TValue>[]));
             }
         }
 
-        private int FindEntry(TKey key) {
-            if( key == null) {
+        private int FindEntry(TKey key)
+        {
+            if (key == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
             }
 
-            if (buckets != null) {
+            if (buckets != null)
+            {
                 int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
-                for (int i = buckets[hashCode % buckets.Length]; i >= 0; i = entries[i].next) {
+                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;
         }
 
-        private void Initialize(int capacity) {
+        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;
@@ -342,9 +419,10 @@ namespace System.Collections.Generic {
             freeList = -1;
         }
 
-        private void Insert(TKey key, TValue value, bool add) {
-        
-            if( key == null ) {
+        private bool TryInsert(TKey key, TValue value, InsertionBehavior behavior)
+        {
+            if (key == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
             }
 
@@ -356,27 +434,38 @@ namespace System.Collections.Generic {
             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) { 
+            for (int i = buckets[targetBucket]; i >= 0; i = entries[i].next)
+            {
+                if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].key, key))
+                {
+                    if (behavior == InsertionBehavior.OverwriteExisting)
+                    {
+                        entries[i].value = value;
+                        version++;
+                        return true;
+                    }
+
+                    if (behavior == InsertionBehavior.ThrowOnExisting)
+                    {
                         ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
                     }
-                    entries[i].value = value;
-                    version++;
-                    return;
-                } 
+
+                    return false;
+                }
 
 #if FEATURE_RANDOMIZED_STRING_HASHING
                 collisionCount++;
 #endif
             }
             int index;
-            if (freeCount > 0) {
+            if (freeCount > 0)
+            {
                 index = freeList;
                 freeList = entries[index].next;
                 freeCount--;
             }
-            else {
+            else
+            {
                 if (count == entries.Length)
                 {
                     Resize();
@@ -399,52 +488,60 @@ namespace System.Collections.Generic {
             // Note, randomized string hashing is turned on by default on coreclr so EqualityComparer<string>.Default will 
             // be using randomized string hashing
 
-            if (collisionCount > HashHelpers.HashCollisionThreshold && comparer == NonRandomizedStringEqualityComparer.Default) 
+            if (collisionCount > HashHelpers.HashCollisionThreshold && comparer == NonRandomizedStringEqualityComparer.Default)
             {
-                comparer = (IEqualityComparer<TKey>) EqualityComparer<string>.Default;
+                comparer = (IEqualityComparer<TKey>)EqualityComparer<string>.Default;
                 Resize(entries.Length, true);
             }
 #endif
 
+            return true;
         }
 
-        public virtual void OnDeserialization(Object sender) {
+        public virtual void OnDeserialization(Object sender)
+        {
             SerializationInfo siInfo;
             HashHelpers.SerializationInfoTable.TryGetValue(this, out siInfo);
-            
-            if (siInfo==null) {
+
+            if (siInfo == null)
+            {
                 // It might be necessary to call OnDeserialization from a container if the container object also implements
                 // OnDeserialization. However, remoting will call OnDeserialization again.
                 // We can return immediately if this function is called twice. 
                 // Note we set remove the serialization info from the table at the end of this method.
                 return;
-            }            
-            
+            }
+
             int realVersion = siInfo.GetInt32(VersionName);
             int hashsize = siInfo.GetInt32(HashSizeName);
-            comparer   = (IEqualityComparer<TKey>)siInfo.GetValue(ComparerName, typeof(IEqualityComparer<TKey>));
-            
-            if( hashsize != 0) {
+            comparer = (IEqualityComparer<TKey>)siInfo.GetValue(ComparerName, typeof(IEqualityComparer<TKey>));
+
+            if (hashsize != 0)
+            {
                 buckets = new int[hashsize];
                 for (int i = 0; i < buckets.Length; i++) buckets[i] = -1;
                 entries = new Entry[hashsize];
                 freeList = -1;
 
-                KeyValuePair<TKey, TValue>[] array = (KeyValuePair<TKey, TValue>[]) 
+                KeyValuePair<TKey, TValue>[] array = (KeyValuePair<TKey, TValue>[])
                     siInfo.GetValue(KeyValuePairsName, typeof(KeyValuePair<TKey, TValue>[]));
 
-                if (array==null) {
+                if (array == null)
+                {
                     ThrowHelper.ThrowSerializationException(ExceptionResource.Serialization_MissingKeys);
                 }
 
-                for (int i=0; i<array.Length; i++) {
-                    if ( array[i].Key == null) {
+                for (int i = 0; i < array.Length; i++)
+                {
+                    if (array[i].Key == null)
+                    {
                         ThrowHelper.ThrowSerializationException(ExceptionResource.Serialization_NullKey);
                     }
-                    Insert(array[i].Key, array[i].Value, true);
+                    Add(array[i].Key, array[i].Value);
                 }
             }
-            else {
+            else
+            {
                 buckets = null;
             }
 
@@ -452,25 +549,32 @@ namespace System.Collections.Generic {
             HashHelpers.SerializationInfoTable.Remove(this);
         }
 
-        private void Resize() {
+        private void Resize()
+        {
             Resize(HashHelpers.ExpandPrime(count), false);
         }
 
-        private void Resize(int newSize, bool forceNewHashCodes) {
+        private void Resize(int newSize, bool forceNewHashCodes)
+        {
             Debug.Assert(newSize >= entries.Length);
             int[] newBuckets = new int[newSize];
             for (int i = 0; i < newBuckets.Length; i++) newBuckets[i] = -1;
             Entry[] newEntries = new Entry[newSize];
             Array.Copy(entries, 0, newEntries, 0, count);
-            if(forceNewHashCodes) {
-                for (int i = 0; i < count; i++) {
-                    if(newEntries[i].hashCode != -1) {
+            if (forceNewHashCodes)
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    if (newEntries[i].hashCode != -1)
+                    {
                         newEntries[i].hashCode = (comparer.GetHashCode(newEntries[i].key) & 0x7FFFFFFF);
                     }
                 }
             }
-            for (int i = 0; i < count; i++) {
-                if (newEntries[i].hashCode >= 0) {
+            for (int i = 0; i < count; i++)
+            {
+                if (newEntries[i].hashCode >= 0)
+                {
                     int bucket = newEntries[i].hashCode % newSize;
                     newEntries[i].next = newBuckets[bucket];
                     newBuckets[bucket] = i;
@@ -480,21 +584,31 @@ namespace System.Collections.Generic {
             entries = newEntries;
         }
 
-        public bool Remove(TKey key) {
-            if(key == null) {
+        // 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.
+        public bool Remove(TKey key)
+        {
+            if (key == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
             }
 
-            if (buckets != null) {
+            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) {
+                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 {
+                        else
+                        {
                             entries[last].next = entries[i].next;
                         }
                         entries[i].hashCode = -1;
@@ -511,9 +625,56 @@ namespace System.Collections.Generic {
             return false;
         }
 
-        public bool TryGetValue(TKey key, out TValue value) {
+        // This overload is a copy of the overload Remove(TKey key) with one additional
+        // statement to copy the value for entry being removed into the output parameter.
+        // Code has been intentionally duplicated for performance reasons.
+        public bool Remove(TKey key, out TValue value)
+        {
+            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;
+                        }
+
+                        value = entries[i].value;
+
+                        entries[i].hashCode = -1;
+                        entries[i].next = freeList;
+                        entries[i].key = default(TKey);
+                        entries[i].value = default(TValue);
+                        freeList = i;
+                        freeCount++;
+                        version++;
+                        return true;
+                    }
+                }
+            }
+            value = default(TValue);
+            return false;
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
             int i = FindEntry(key);
-            if (i >= 0) {
+            if (i >= 0)
+            {
                 value = entries[i].value;
                 return true;
             }
@@ -536,195 +697,246 @@ namespace System.Collections.Generic {
             return defaultValue;
         }
 
-        bool ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly {
+        public bool TryAdd(TKey key, TValue value) => TryInsert(key, value, InsertionBehavior.None);
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
+        {
             get { return false; }
         }
 
-        void ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[] array, int index) {
+        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
+        {
             CopyTo(array, index);
         }
 
-        void ICollection.CopyTo(Array array, int index) {
-            if (array == null) {
+        void ICollection.CopyTo(Array array, int index)
+        {
+            if (array == null)
+            {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
             }
-            
-            if (array.Rank != 1) {
+
+            if (array.Rank != 1)
+            {
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
             }
 
-            if( array.GetLowerBound(0) != 0 ) {
+            if (array.GetLowerBound(0) != 0)
+            {
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
             }
-            
-            if (index < 0 || index > array.Length) {
+
+            if (index < 0 || index > array.Length)
+            {
                 ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
             }
 
-            if (array.Length - index < Count) {
+            if (array.Length - index < Count)
+            {
                 ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
             }
-            
-            KeyValuePair<TKey,TValue>[] pairs = array as KeyValuePair<TKey,TValue>[];
-            if (pairs != null) {
+
+            KeyValuePair<TKey, TValue>[] pairs = array as KeyValuePair<TKey, TValue>[];
+            if (pairs != null)
+            {
                 CopyTo(pairs, index);
             }
-            else if( array is DictionaryEntry[]) {
+            else if (array is DictionaryEntry[])
+            {
                 DictionaryEntry[] dictEntryArray = array as DictionaryEntry[];
                 Entry[] entries = this.entries;
-                for (int i = 0; i < count; i++) {
-                    if (entries[i].hashCode >= 0) {
+                for (int i = 0; i < count; i++)
+                {
+                    if (entries[i].hashCode >= 0)
+                    {
                         dictEntryArray[index++] = new DictionaryEntry(entries[i].key, entries[i].value);
                     }
-                }                
+                }
             }
-            else {
+            else
+            {
                 object[] objects = array as object[];
-                if (objects == null) {
+                if (objects == null)
+                {
                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                 }
 
-                try {
+                try
+                {
                     int count = this.count;
                     Entry[] entries = this.entries;
-                    for (int i = 0; i < count; i++) {
-                        if (entries[i].hashCode >= 0) {
-                            objects[index++] = new KeyValuePair<TKey,TValue>(entries[i].key, entries[i].value);
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (entries[i].hashCode >= 0)
+                        {
+                            objects[index++] = new KeyValuePair<TKey, TValue>(entries[i].key, entries[i].value);
                         }
                     }
                 }
-                catch(ArrayTypeMismatchException) {
+                catch (ArrayTypeMismatchException)
+                {
                     ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                 }
             }
         }
 
-        IEnumerator IEnumerable.GetEnumerator() {
+        IEnumerator IEnumerable.GetEnumerator()
+        {
             return new Enumerator(this, Enumerator.KeyValuePair);
         }
-    
-        bool ICollection.IsSynchronized {
+
+        bool ICollection.IsSynchronized
+        {
             get { return false; }
         }
 
-        object ICollection.SyncRoot { 
-            get { 
-                if( _syncRoot == null) {
-                    System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);    
+        object ICollection.SyncRoot
+        {
+            get
+            {
+                if (_syncRoot == null)
+                {
+                    System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);
                 }
-                return _syncRoot; 
+                return _syncRoot;
             }
         }
 
-        bool IDictionary.IsFixedSize {
+        bool IDictionary.IsFixedSize
+        {
             get { return false; }
         }
 
-        bool IDictionary.IsReadOnly {
+        bool IDictionary.IsReadOnly
+        {
             get { return false; }
         }
 
-        ICollection IDictionary.Keys {
+        ICollection IDictionary.Keys
+        {
             get { return (ICollection)Keys; }
         }
-    
-        ICollection IDictionary.Values {
+
+        ICollection IDictionary.Values
+        {
             get { return (ICollection)Values; }
         }
-    
-        object IDictionary.this[object key] {
-            get { 
-                if( IsCompatibleKey(key)) {                
+
+        object IDictionary.this[object key]
+        {
+            get
+            {
+                if (IsCompatibleKey(key))
+                {
                     int i = FindEntry((TKey)key);
-                    if (i >= 0) { 
-                        return entries[i].value;                
+                    if (i >= 0)
+                    {
+                        return entries[i].value;
                     }
                 }
                 return null;
             }
-            set {                 
+            set
+            {
                 if (key == null)
                 {
-                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);                          
+                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
                 }
                 ThrowHelper.IfNullAndNullsAreIllegalThenThrow<TValue>(value, ExceptionArgument.value);
 
-                try {
+                try
+                {
                     TKey tempKey = (TKey)key;
-                    try {
-                        this[tempKey] = (TValue)value; 
+                    try
+                    {
+                        this[tempKey] = (TValue)value;
                     }
-                    catch (InvalidCastException) { 
-                        ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));   
+                    catch (InvalidCastException)
+                    {
+                        ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));
                     }
                 }
-                catch (InvalidCastException) { 
+                catch (InvalidCastException)
+                {
                     ThrowHelper.ThrowWrongKeyTypeArgumentException(key, typeof(TKey));
                 }
             }
         }
 
-        private static bool IsCompatibleKey(object key) {
-            if( key == null) {
-                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);                          
-                }
-            return (key is TKey); 
+        private static bool IsCompatibleKey(object key)
+        {
+            if (key == null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
+            }
+            return (key is TKey);
         }
-    
-        void IDictionary.Add(object key, object value) {            
+
+        void IDictionary.Add(object key, object value)
+        {
             if (key == null)
             {
-                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);                          
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
             }
             ThrowHelper.IfNullAndNullsAreIllegalThenThrow<TValue>(value, ExceptionArgument.value);
 
-            try {
+            try
+            {
                 TKey tempKey = (TKey)key;
 
-                try {
+                try
+                {
                     Add(tempKey, (TValue)value);
                 }
-                catch (InvalidCastException) { 
-                    ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));   
+                catch (InvalidCastException)
+                {
+                    ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));
                 }
             }
-            catch (InvalidCastException) { 
+            catch (InvalidCastException)
+            {
                 ThrowHelper.ThrowWrongKeyTypeArgumentException(key, typeof(TKey));
             }
         }
-    
-        bool IDictionary.Contains(object key) {    
-            if(IsCompatibleKey(key)) {
+
+        bool IDictionary.Contains(object key)
+        {
+            if (IsCompatibleKey(key))
+            {
                 return ContainsKey((TKey)key);
             }
-       
+
             return false;
         }
-    
-        IDictionaryEnumerator IDictionary.GetEnumerator() {
+
+        IDictionaryEnumerator IDictionary.GetEnumerator()
+        {
             return new Enumerator(this, Enumerator.DictEntry);
         }
-    
-        void IDictionary.Remove(object key) {            
-            if(IsCompatibleKey(key)) {
+
+        void IDictionary.Remove(object key)
+        {
+            if (IsCompatibleKey(key))
+            {
                 Remove((TKey)key);
             }
         }
 
         [Serializable]
-        public struct Enumerator: IEnumerator<KeyValuePair<TKey,TValue>>,
+        public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>,
             IDictionaryEnumerator
         {
-            private Dictionary<TKey,TValue> dictionary;
+            private Dictionary<TKey, TValue> dictionary;
             private int version;
             private int index;
-            private KeyValuePair<TKey,TValue> current;
+            private KeyValuePair<TKey, TValue> current;
             private int getEnumeratorRetType;  // What should Enumerator.Current return?
-            
+
             internal const int DictEntry = 1;
             internal const int KeyValuePair = 2;
 
-            internal Enumerator(Dictionary<TKey,TValue> dictionary, int getEnumeratorRetType) {
+            internal Enumerator(Dictionary<TKey, TValue> dictionary, int getEnumeratorRetType)
+            {
                 this.dictionary = dictionary;
                 version = dictionary.version;
                 index = 0;
@@ -732,15 +944,19 @@ namespace System.Collections.Generic {
                 current = new KeyValuePair<TKey, TValue>();
             }
 
-            public bool MoveNext() {
-                if (version != dictionary.version) {
+            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 Int32.MaxValue
-                while ((uint)index < (uint)dictionary.count) {
-                    if (dictionary.entries[index].hashCode >= 0) {
+                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;
@@ -753,187 +969,236 @@ namespace System.Collections.Generic {
                 return false;
             }
 
-            public KeyValuePair<TKey,TValue> Current {
+            public KeyValuePair<TKey, TValue> Current
+            {
                 get { return current; }
             }
 
-            public void Dispose() {
+            public void Dispose()
+            {
             }
 
-            object IEnumerator.Current {
-                get { 
-                    if( index == 0 || (index == dictionary.count + 1)) {
-                        ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();                        
-                    }      
+            object IEnumerator.Current
+            {
+                get
+                {
+                    if (index == 0 || (index == dictionary.count + 1))
+                    {
+                        ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
+                    }
 
-                    if (getEnumeratorRetType == DictEntry) {
+                    if (getEnumeratorRetType == DictEntry)
+                    {
                         return new System.Collections.DictionaryEntry(current.Key, current.Value);
-                    } else {
+                    }
+                    else
+                    {
                         return new KeyValuePair<TKey, TValue>(current.Key, current.Value);
                     }
                 }
             }
 
-            void IEnumerator.Reset() {
-                if (version != dictionary.version) {
+            void IEnumerator.Reset()
+            {
+                if (version != dictionary.version)
+                {
                     ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
                 }
 
                 index = 0;
-                current = new KeyValuePair<TKey, TValue>();    
+                current = new KeyValuePair<TKey, TValue>();
             }
 
-            DictionaryEntry IDictionaryEnumerator.Entry {
-                get { 
-                    if( index == 0 || (index == dictionary.count + 1)) {
-                         ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();                        
-                    }                        
-                    
-                    return new DictionaryEntry(current.Key, current.Value); 
+            DictionaryEntry IDictionaryEnumerator.Entry
+            {
+                get
+                {
+                    if (index == 0 || (index == dictionary.count + 1))
+                    {
+                        ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
+                    }
+
+                    return new DictionaryEntry(current.Key, current.Value);
                 }
             }
 
-            object IDictionaryEnumerator.Key {
-                get { 
-                    if( index == 0 || (index == dictionary.count + 1)) {
-                         ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();                        
-                    }                        
-                    
-                    return current.Key; 
+            object IDictionaryEnumerator.Key
+            {
+                get
+                {
+                    if (index == 0 || (index == dictionary.count + 1))
+                    {
+                        ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
+                    }
+
+                    return current.Key;
                 }
             }
 
-            object IDictionaryEnumerator.Value {
-                get { 
-                    if( index == 0 || (index == dictionary.count + 1)) {
-                         ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();                        
-                    }                        
-                    
-                    return current.Value; 
+            object IDictionaryEnumerator.Value
+            {
+                get
+                {
+                    if (index == 0 || (index == dictionary.count + 1))
+                    {
+                        ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
+                    }
+
+                    return current.Value;
                 }
             }
         }
 
         [DebuggerTypeProxy(typeof(Mscorlib_DictionaryKeyCollectionDebugView<,>))]
-        [DebuggerDisplay("Count = {Count}")]        
+        [DebuggerDisplay("Count = {Count}")]
         [Serializable]
-        public sealed class KeyCollection: ICollection<TKey>, ICollection, IReadOnlyCollection<TKey>
+        public sealed class KeyCollection : ICollection<TKey>, ICollection, IReadOnlyCollection<TKey>
         {
-            private Dictionary<TKey,TValue> dictionary;
+            private Dictionary<TKey, TValue> dictionary;
 
-            public KeyCollection(Dictionary<TKey,TValue> dictionary) {
-                if (dictionary == null) {
+            public KeyCollection(Dictionary<TKey, TValue> dictionary)
+            {
+                if (dictionary == null)
+                {
                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
                 }
                 this.dictionary = dictionary;
             }
 
-            public Enumerator GetEnumerator() {
+            public Enumerator GetEnumerator()
+            {
                 return new Enumerator(dictionary);
             }
 
-            public void CopyTo(TKey[] array, int index) {
-                if (array == null) {
+            public void CopyTo(TKey[] array, int index)
+            {
+                if (array == null)
+                {
                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
                 }
 
-                if (index < 0 || index > array.Length) {
+                if (index < 0 || index > array.Length)
+                {
                     ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
                 }
 
-                if (array.Length - index < dictionary.Count) {
+                if (array.Length - index < dictionary.Count)
+                {
                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
                 }
-                
+
                 int count = dictionary.count;
                 Entry[] entries = dictionary.entries;
-                for (int i = 0; i < count; i++) {
+                for (int i = 0; i < count; i++)
+                {
                     if (entries[i].hashCode >= 0) array[index++] = entries[i].key;
                 }
             }
 
-            public int Count {
+            public int Count
+            {
                 get { return dictionary.Count; }
             }
 
-            bool ICollection<TKey>.IsReadOnly {
+            bool ICollection<TKey>.IsReadOnly
+            {
                 get { return true; }
             }
 
-            void ICollection<TKey>.Add(TKey item){
+            void ICollection<TKey>.Add(TKey item)
+            {
                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
             }
-            
-            void ICollection<TKey>.Clear(){
+
+            void ICollection<TKey>.Clear()
+            {
                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
             }
 
-            bool ICollection<TKey>.Contains(TKey item){
+            bool ICollection<TKey>.Contains(TKey item)
+            {
                 return dictionary.ContainsKey(item);
             }
 
-            bool ICollection<TKey>.Remove(TKey item){
+            bool ICollection<TKey>.Remove(TKey item)
+            {
                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
                 return false;
             }
-            
-            IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator() {
+
+            IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator()
+            {
                 return new Enumerator(dictionary);
             }
 
-            IEnumerator IEnumerable.GetEnumerator() {
-                return new Enumerator(dictionary);                
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return new Enumerator(dictionary);
             }
 
-            void ICollection.CopyTo(Array array, int index) {
-                if (array==null) {
+            void ICollection.CopyTo(Array array, int index)
+            {
+                if (array == null)
+                {
                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
                 }
 
-                if (array.Rank != 1) {
+                if (array.Rank != 1)
+                {
                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
                 }
 
-                if( array.GetLowerBound(0) != 0 ) {
+                if (array.GetLowerBound(0) != 0)
+                {
                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
                 }
 
-                if (index < 0 || index > array.Length) {
+                if (index < 0 || index > array.Length)
+                {
                     ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
                 }
 
-                if (array.Length - index < dictionary.Count) {
+                if (array.Length - index < dictionary.Count)
+                {
                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
                 }
-                
+
                 TKey[] keys = array as TKey[];
-                if (keys != null) {
+                if (keys != null)
+                {
                     CopyTo(keys, index);
                 }
-                else {
+                else
+                {
                     object[] objects = array as object[];
-                    if (objects == null) {
+                    if (objects == null)
+                    {
                         ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                     }
-                                         
+
                     int count = dictionary.count;
                     Entry[] entries = dictionary.entries;
-                    try {
-                        for (int i = 0; i < count; i++) {
+                    try
+                    {
+                        for (int i = 0; i < count; i++)
+                        {
                             if (entries[i].hashCode >= 0) objects[index++] = entries[i].key;
                         }
-                    }                    
-                    catch(ArrayTypeMismatchException) {
+                    }
+                    catch (ArrayTypeMismatchException)
+                    {
                         ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                     }
                 }
             }
 
-            bool ICollection.IsSynchronized {
+            bool ICollection.IsSynchronized
+            {
                 get { return false; }
             }
 
-            Object ICollection.SyncRoot { 
+            Object ICollection.SyncRoot
+            {
                 get { return ((ICollection)dictionary).SyncRoot; }
             }
 
@@ -944,24 +1209,30 @@ namespace System.Collections.Generic {
                 private int index;
                 private int version;
                 private TKey currentKey;
-            
-                internal Enumerator(Dictionary<TKey, TValue> dictionary) {
+
+                internal Enumerator(Dictionary<TKey, TValue> dictionary)
+                {
                     this.dictionary = dictionary;
                     version = dictionary.version;
                     index = 0;
-                    currentKey = default(TKey);                    
+                    currentKey = default(TKey);
                 }
 
-                public void Dispose() {
+                public void Dispose()
+                {
                 }
 
-                public bool MoveNext() {
-                    if (version != dictionary.version) {
+                public bool MoveNext()
+                {
+                    if (version != dictionary.version)
+                    {
                         ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
                     }
 
-                    while ((uint)index < (uint)dictionary.count) {
-                        if (dictionary.entries[index].hashCode >= 0) {
+                    while ((uint)index < (uint)dictionary.count)
+                    {
+                        if (dictionary.entries[index].hashCode >= 0)
+                        {
                             currentKey = dictionary.entries[index].key;
                             index++;
                             return true;
@@ -973,153 +1244,189 @@ namespace System.Collections.Generic {
                     currentKey = default(TKey);
                     return false;
                 }
-                
-                public TKey Current {
-                    get {                        
+
+                public TKey Current
+                {
+                    get
+                    {
                         return currentKey;
                     }
                 }
 
-                Object System.Collections.IEnumerator.Current {
-                    get {                      
-                        if( index == 0 || (index == dictionary.count + 1)) {
-                             ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();                        
-                        }                        
-                        
+                Object System.Collections.IEnumerator.Current
+                {
+                    get
+                    {
+                        if (index == 0 || (index == dictionary.count + 1))
+                        {
+                            ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
+                        }
+
                         return currentKey;
                     }
                 }
-                
-                void System.Collections.IEnumerator.Reset() {
-                    if (version != dictionary.version) {
-                        ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();                        
+
+                void System.Collections.IEnumerator.Reset()
+                {
+                    if (version != dictionary.version)
+                    {
+                        ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
                     }
 
-                    index = 0;                    
+                    index = 0;
                     currentKey = default(TKey);
                 }
-            }                        
+            }
         }
 
         [DebuggerTypeProxy(typeof(Mscorlib_DictionaryValueCollectionDebugView<,>))]
         [DebuggerDisplay("Count = {Count}")]
         [Serializable]
-        public sealed class ValueCollection: ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>
+        public sealed class ValueCollection : ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>
         {
-            private Dictionary<TKey,TValue> dictionary;
+            private Dictionary<TKey, TValue> dictionary;
 
-            public ValueCollection(Dictionary<TKey,TValue> dictionary) {
-                if (dictionary == null) {
+            public ValueCollection(Dictionary<TKey, TValue> dictionary)
+            {
+                if (dictionary == null)
+                {
                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
                 }
                 this.dictionary = dictionary;
             }
 
-            public Enumerator GetEnumerator() {
-                return new Enumerator(dictionary);                
+            public Enumerator GetEnumerator()
+            {
+                return new Enumerator(dictionary);
             }
 
-            public void CopyTo(TValue[] array, int index) {
-                if (array == null) {
+            public void CopyTo(TValue[] array, int index)
+            {
+                if (array == null)
+                {
                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
                 }
 
-                if (index < 0 || index > array.Length) {
+                if (index < 0 || index > array.Length)
+                {
                     ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
                 }
 
-                if (array.Length - index < dictionary.Count) {
+                if (array.Length - index < dictionary.Count)
+                {
                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
                 }
-                
+
                 int count = dictionary.count;
                 Entry[] entries = dictionary.entries;
-                for (int i = 0; i < count; i++) {
+                for (int i = 0; i < count; i++)
+                {
                     if (entries[i].hashCode >= 0) array[index++] = entries[i].value;
                 }
             }
 
-            public int Count {
+            public int Count
+            {
                 get { return dictionary.Count; }
             }
 
-            bool ICollection<TValue>.IsReadOnly {
+            bool ICollection<TValue>.IsReadOnly
+            {
                 get { return true; }
             }
 
-            void ICollection<TValue>.Add(TValue item){
+            void ICollection<TValue>.Add(TValue item)
+            {
                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
             }
 
-            bool ICollection<TValue>.Remove(TValue item){
+            bool ICollection<TValue>.Remove(TValue item)
+            {
                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
                 return false;
             }
 
-            void ICollection<TValue>.Clear(){
+            void ICollection<TValue>.Clear()
+            {
                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
             }
 
-            bool ICollection<TValue>.Contains(TValue item){
+            bool ICollection<TValue>.Contains(TValue item)
+            {
                 return dictionary.ContainsValue(item);
             }
 
-            IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator() {
+            IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator()
+            {
                 return new Enumerator(dictionary);
             }
 
-            IEnumerator IEnumerable.GetEnumerator() {
-                return new Enumerator(dictionary);                
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return new Enumerator(dictionary);
             }
 
-            void ICollection.CopyTo(Array array, int index) {
-                if (array == null) {
+            void ICollection.CopyTo(Array array, int index)
+            {
+                if (array == null)
+                {
                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
                 }
 
-                if (array.Rank != 1) {
+                if (array.Rank != 1)
+                {
                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
                 }
 
-                if( array.GetLowerBound(0) != 0 ) {
+                if (array.GetLowerBound(0) != 0)
+                {
                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
                 }
 
-                if (index < 0 || index > array.Length) { 
+                if (index < 0 || index > array.Length)
+                {
                     ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
                 }
 
                 if (array.Length - index < dictionary.Count)
                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
-                
+
                 TValue[] values = array as TValue[];
-                if (values != null) {
+                if (values != null)
+                {
                     CopyTo(values, index);
                 }
-                else {
+                else
+                {
                     object[] objects = array as object[];
-                    if (objects == null) {
+                    if (objects == null)
+                    {
                         ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                     }
 
                     int count = dictionary.count;
                     Entry[] entries = dictionary.entries;
-                    try {
-                        for (int i = 0; i < count; i++) {
+                    try
+                    {
+                        for (int i = 0; i < count; i++)
+                        {
                             if (entries[i].hashCode >= 0) objects[index++] = entries[i].value;
                         }
                     }
-                    catch(ArrayTypeMismatchException) {
+                    catch (ArrayTypeMismatchException)
+                    {
                         ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
                     }
                 }
             }
 
-            bool ICollection.IsSynchronized {
+            bool ICollection.IsSynchronized
+            {
                 get { return false; }
             }
 
-            Object ICollection.SyncRoot { 
+            Object ICollection.SyncRoot
+            {
                 get { return ((ICollection)dictionary).SyncRoot; }
             }
 
@@ -1130,24 +1437,30 @@ namespace System.Collections.Generic {
                 private int index;
                 private int version;
                 private TValue currentValue;
-            
-                internal Enumerator(Dictionary<TKey, TValue> dictionary) {
+
+                internal Enumerator(Dictionary<TKey, TValue> dictionary)
+                {
                     this.dictionary = dictionary;
                     version = dictionary.version;
                     index = 0;
                     currentValue = default(TValue);
                 }
 
-                public void Dispose() {
+                public void Dispose()
+                {
                 }
 
-                public bool MoveNext() {                    
-                    if (version != dictionary.version) {
+                public bool MoveNext()
+                {
+                    if (version != dictionary.version)
+                    {
                         ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
                     }
-                    
-                    while ((uint)index < (uint)dictionary.count) {
-                        if (dictionary.entries[index].hashCode >= 0) {
+
+                    while ((uint)index < (uint)dictionary.count)
+                    {
+                        if (dictionary.entries[index].hashCode >= 0)
+                        {
                             currentValue = dictionary.entries[index].value;
                             index++;
                             return true;
@@ -1158,28 +1471,35 @@ namespace System.Collections.Generic {
                     currentValue = default(TValue);
                     return false;
                 }
-                
-                public TValue Current {
-                    get {                        
+
+                public TValue Current
+                {
+                    get
+                    {
                         return currentValue;
                     }
                 }
 
-                Object System.Collections.IEnumerator.Current {
-                    get {                      
-                        if( index == 0 || (index == dictionary.count + 1)) {
-                             ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();                        
-                        }                        
-                        
+                Object System.Collections.IEnumerator.Current
+                {
+                    get
+                    {
+                        if (index == 0 || (index == dictionary.count + 1))
+                        {
+                            ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
+                        }
+
                         return currentValue;
                     }
                 }
-                
-                void System.Collections.IEnumerator.Reset() {
-                    if (version != dictionary.version) {
+
+                void System.Collections.IEnumerator.Reset()
+                {
+                    if (version != dictionary.version)
+                    {
                         ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
                     }
-                    index = 0;                    
+                    index = 0;
                     currentValue = default(TValue);
                 }
             }