Pre-box Empty enumerator

Author: benaadams

src/Microsoft.AspNet.WebUtilities/SafeLazyDictionary.cs

@@ -12,9 +12,13 @@ internal class SafeLazyDictionary<TValue> : IDictionary<string, TValue>
 #if !DNXCORE50
         private static readonly string[] EmptyKeys = new string[0];
         private static readonly TValue[] EmptyValues = new TValue[0];
-        private static readonly KeyValuePair<string, TValue>[] EmptyEnumerator = new KeyValuePair<string, TValue>[0];
 #endif 
-        public IDictionary<string, TValue> Store { get; set; }
+        private static readonly Enumerator EmptyEnumerator = new Enumerator();
+        // Pre-box
+        private static readonly IEnumerator<KeyValuePair<string, TValue>> EmptyIEnumeratorType = EmptyEnumerator;
+        private static readonly IEnumerator EmptyIEnumerator = EmptyEnumerator;
+
+        private Dictionary<string, TValue> Store { get; set; }
 
         public SafeLazyDictionary()
         {
@@ -133,11 +137,14 @@ public void Clear()
 
         public bool Contains(KeyValuePair<string, TValue> item)
         {
-            if (Store == null)
+            TValue value;
+            if (Store == null || 
+                !Store.TryGetValue(item.Key, out value) || 
+                !value.Equals(item.Value))
             {
                 return false;
             }
-            return Store.Contains(item);
+            return true;
         }
 
         public bool ContainsKey(string key)
@@ -162,20 +169,7 @@ public void CopyTo(KeyValuePair<string, TValue>[] array, int arrayIndex)
                 arrayIndex++;
             }
         }
-
-        public IEnumerator<KeyValuePair<string, TValue>> GetEnumerator()
-        {
-            if (Store == null)
-            {
-#if DNXCORE50
-                return ((IEnumerable<KeyValuePair<string, TValue>>)Array.Empty<KeyValuePair<string, TValue>>()).GetEnumerator();
-#else
-                return ((IEnumerable<KeyValuePair<string, TValue>>)EmptyEnumerator).GetEnumerator();
-#endif
-            }
-            return Store.GetEnumerator();
-        }
-
+        
         public bool Remove(KeyValuePair<string, TValue> item)
         {
             if (Store == null)
@@ -211,17 +205,83 @@ public bool TryGetValue(string key, out TValue value)
             return Store.TryGetValue(key, out value);
         }
 
+        public Enumerator GetEnumerator()
+        {
+            if (Store == null)
+            {
+                return EmptyEnumerator;
+            }
+            return new Enumerator(Store.GetEnumerator());
+        }
+
+        IEnumerator<KeyValuePair<string, TValue>> IEnumerable<KeyValuePair<string, TValue>>.GetEnumerator()
+        {
+            if (Store == null)
+            {
+                return EmptyIEnumeratorType;
+            }
+            return Store.GetEnumerator();
+        }
         IEnumerator IEnumerable.GetEnumerator()
         {
             if (Store == null)
             {
-#if DNXCORE50
-                return Array.Empty<TValue>().GetEnumerator();
-#else
-                return EmptyEnumerator.GetEnumerator();
-#endif
+                return EmptyIEnumerator;
             }
             return Store.GetEnumerator();
         }
+
+        public struct Enumerator : IEnumerator<KeyValuePair<string, TValue>>
+        {
+            private Dictionary<string, TValue>.Enumerator _dictionaryEnumerator;
+            private bool _notEmpty;
+
+            internal Enumerator(Dictionary<string, TValue>.Enumerator dictionaryEnumerator)
+            {
+                _dictionaryEnumerator = dictionaryEnumerator;
+                _notEmpty = true;
+            }
+
+            public bool MoveNext()
+            {
+                if (_notEmpty)
+                {
+                    return _dictionaryEnumerator.MoveNext();
+                }
+                return false;
+            }
+
+            public KeyValuePair<string, TValue> Current
+            {
+                get
+                {
+                    if (_notEmpty)
+                    {
+                        return _dictionaryEnumerator.Current;
+                    }
+                    return default(KeyValuePair<string, TValue>);
+                }
+            }
+
+            public void Dispose()
+            {
+            }
+
+            object IEnumerator.Current
+            {
+                get
+                {
+                    return Current;
+                }
+            }
+
+            void IEnumerator.Reset()
+            {
+                if (_notEmpty)
+                {
+                    ((IEnumerator)_dictionaryEnumerator).Reset();
+                }
+            }
+        }
     }
 }