Reduce boxing, Pre-box Empty enumerators

Author: benaadams

src/Microsoft.AspNet.Http/Features/FormFeature.cs

@@ -84,7 +84,7 @@ public IFormCollection ReadForm()
 
             if (!HasFormContentType)
             {
-                throw new InvalidOperationException("Incorrect Content-Type: " + _request.ContentType);
+                throw new InvalidOperationException($"Incorrect Content-Type: {_request.ContentType}");
             }
 
             // TODO: Avoid Sync-over-Async http://blogs.msdn.com/b/pfxteam/archive/2012/04/13/10293638.aspx
@@ -115,7 +115,7 @@ private async Task<IFormCollection> InnerReadFormAsync(CancellationToken cancell
         {
             if (!HasFormContentType)
             {
-                throw new InvalidOperationException("Incorrect Content-Type: " + _request.ContentType);
+                throw new InvalidOperationException($"Incorrect Content-Type: {_request.ContentType}");
             }
 
             cancellationToken.ThrowIfCancellationRequested();
@@ -126,7 +126,7 @@ private async Task<IFormCollection> InnerReadFormAsync(CancellationToken cancell
             FormFileCollection files = null;
 
             // Some of these code paths use StreamReader which does not support cancellation tokens.
-            using (cancellationToken.Register(_request.HttpContext.Abort))
+            using (cancellationToken.Register((Action)_request.HttpContext.Abort))
             {
                 var contentType = ContentType;
                 // Check the content-type
@@ -179,7 +179,7 @@ private async Task<IFormCollection> InnerReadFormAsync(CancellationToken cancell
                         }
                         else
                         {
-                            System.Diagnostics.Debug.Assert(false, "Unrecognized content-disposition for this section: " + section.ContentDisposition);
+                            System.Diagnostics.Debug.Assert(false, $"Unrecognized content-disposition for this section: {section.ContentDisposition}");
                         }
 
                         section = await multipartReader.ReadNextSectionAsync(cancellationToken);

src/Microsoft.AspNet.Http/ReadableStringCollection.cs

@@ -18,7 +18,9 @@ public class ReadableStringCollection : IReadableStringCollection
 #if !DNXCORE50
         private static readonly string[] EmptyKeys = new string[0];
 #endif
-        private static readonly IEnumerable<KeyValuePair<string, StringValues>> EmptyEnumerable = new KeyValuePair<string, StringValues>[0];
+        // Pre-box empty case
+        private static readonly IEnumerator<KeyValuePair<string, StringValues>> EmptyEnumerator
+            = ((IEnumerable<KeyValuePair<string, StringValues>>)new KeyValuePair<string, StringValues>[0]).GetEnumerator();
 
         internal ReadableStringCollection()
         {
@@ -126,7 +128,7 @@ public IEnumerator<KeyValuePair<string, StringValues>> GetEnumerator()
         {
             if (Store == null)
             {
-                return EmptyEnumerable.GetEnumerator();
+                return EmptyEnumerator;
             }
 
             return Store.GetEnumerator();

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,84 @@ 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>>
+        {
+            // Do NOT make this readonly, or MoveNext will not work
+            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();
+                }
+            }
+        }
     }
 }