[Design] Reduce DI Allocations

src/Microsoft.Framework.DependencyInjection/ServiceLookup/ServiceScope.cs

@@ -8,20 +8,37 @@ namespace Microsoft.Framework.DependencyInjection.ServiceLookup
     internal class ServiceScope : IServiceScope
     {
         private readonly ServiceProvider _scopedProvider;
+        private readonly ServiceScopeFactory _parentFactory;
 
         public ServiceScope(ServiceProvider scopedProvider)
         {
             _scopedProvider = scopedProvider;
         }
+        internal ServiceScope(ServiceProvider scopedProvider, ServiceScopeFactory parentFactory)
+        {
+            _scopedProvider = scopedProvider;
+            _parentFactory = parentFactory;
+        }
 
         public IServiceProvider ServiceProvider
         {
             get { return _scopedProvider; }
         }
 
+        internal void Reset()
+        {
+            // Double wash
+            _scopedProvider.Dispose();
+        }
+
         public void Dispose()
         {
             _scopedProvider.Dispose();
+
+            if (_parentFactory != null)
+            {
+                _parentFactory.PoolScope(this);
+            }
         }
     }
 }

src/Microsoft.Framework.DependencyInjection/ServiceLookup/ServiceScopeFactory.cs

@@ -1,10 +1,16 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
+using System.Collections.Concurrent;
+
 namespace Microsoft.Framework.DependencyInjection.ServiceLookup
 {
     internal class ServiceScopeFactory : IServiceScopeFactory
     {
+        private static int _maxPooled = 32 * Environment.ProcessorCount;
+        private static readonly ConcurrentQueue<ServiceScope> _scopePool = new ConcurrentQueue<ServiceScope>();
+
         private readonly ServiceProvider _provider;
 
         public ServiceScopeFactory(ServiceProvider provider)
@@ -14,7 +20,23 @@ public ServiceScopeFactory(ServiceProvider provider)
 
         public IServiceScope CreateScope()
         {
-            return new ServiceScope(new ServiceProvider(_provider));
+            ServiceScope scope;
+            if (_scopePool.TryDequeue(out scope))
+            {
+                scope.Reset();
+                return scope;
+            }
+            return new ServiceScope(new ServiceProvider(_provider), this);
+        }
+
+        internal void PoolScope(ServiceScope scope)
+        {
+            // Benign race condition
+            if (_scopePool.Count < _maxPooled)
+            {
+                _scopePool.Enqueue(scope);
+            }
         }
+
     }
 }

src/Microsoft.Framework.DependencyInjection/ServiceProvider.cs

@@ -145,15 +145,12 @@ internal IServiceCallSite GetResolveCallSite(IService service, ISet<Type> callSi
 
         public void Dispose()
         {
-            var disposables = Interlocked.Exchange(ref _disposables, null);
-
-            if (disposables != null)
+            IDisposable disposable;
+            while (_disposables.TryTake(out disposable))
             {
-                foreach (var disposable in disposables)
-                {
-                    disposable.Dispose();
-                }
+                disposable.Dispose();
             }
+            _resolvedServices.Clear();
         }
 
         private object CaptureDisposable(object service)