[Design] Reduce DI Allocations

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

@@ -8,20 +8,32 @@ namespace Microsoft.Framework.DependencyInjection.ServiceLookup
     internal class ServiceScope : IServiceScope
     {
         private readonly ServiceProvider _scopedProvider;
-
-        public ServiceScope(ServiceProvider scopedProvider)
+        private readonly ServiceScopeFactory _parentFactory;
+
+        public ServiceScope(ServiceProvider scopedProvider, ServiceScopeFactory parentFactory)
         {
             _scopedProvider = scopedProvider;
+            _parentFactory = parentFactory;
         }
 
         public IServiceProvider ServiceProvider
         {
             get { return _scopedProvider; }
         }
 
+        internal void Reset()
+        {
+            _scopedProvider.Reset();
+        }
+
         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 _capacity = 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 < _capacity)
+            {
+                _scopePool.Enqueue(scope);
+            }
         }
+
     }
 }

src/Microsoft.Framework.DependencyInjection/ServiceProvider.cs

@@ -25,6 +25,7 @@ internal class ServiceProvider : IServiceProvider, IDisposable
 
         private readonly Dictionary<IService, object> _resolvedServices = new Dictionary<IService, object>();
         private ConcurrentBag<IDisposable> _disposables = new ConcurrentBag<IDisposable>();
+        private ConcurrentBag<IDisposable> _offlineDisposables;
 
         public ServiceProvider(IEnumerable<ServiceDescriptor> serviceDescriptors)
         {
@@ -143,16 +144,28 @@ internal IServiceCallSite GetResolveCallSite(IService service, ISet<Type> callSi
             }
         }
 
+        internal void Reset()
+        {
+            if (_offlineDisposables == null)
+            {
+                throw new InvalidOperationException("ServiceProvider reused before being disposed");
+            }
+            _disposables = _offlineDisposables;
+            _offlineDisposables = null;
+        }
+
         public void Dispose()
         {
             var disposables = Interlocked.Exchange(ref _disposables, null);
-
             if (disposables != null)
             {
-                foreach (var disposable in disposables)
+                IDisposable disposable;
+                while (disposables.TryTake(out disposable))
                 {
                     disposable.Dispose();
                 }
+                _resolvedServices.Clear();
+                _offlineDisposables = disposables;
             }
         }