Fixes race condition on captive scoped services

src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs

@@ -28,7 +28,6 @@ internal sealed class ExpressionResolverBuilder : CallSiteVisitor<object, Expres
 
         private static readonly ParameterExpression ResolvedServices = Expression.Variable(typeof(IDictionary<ServiceCacheKey, object>), ScopeParameter.Name + "resolvedServices");
         private static readonly ParameterExpression Sync = Expression.Variable(typeof(object), ScopeParameter.Name + "sync");
-        private static readonly ParameterExpression IsRootScope = Expression.Variable(typeof(bool), ScopeParameter.Name + "isRootScope");
         private static readonly BinaryExpression ResolvedServicesVariableAssignment =
             Expression.Assign(ResolvedServices,
                 Expression.Property(
@@ -91,7 +90,7 @@ private Expression<Func<ServiceProviderEngineScope, object>> BuildExpression(Ser
             {
                 return Expression.Lambda<Func<ServiceProviderEngineScope, object>>(
                     Expression.Block(
-                        new[] { IsRootScope, ResolvedServices, Sync },
+                        new[] { ResolvedServices, Sync },
                         ResolvedServicesVariableAssignment,
                         SyncVariableAssignment,
                         BuildScopedExpression(callSite)),

src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/ServiceProviderEngineScope.cs

@@ -11,7 +11,7 @@ namespace Microsoft.Extensions.DependencyInjection.ServiceLookup
     internal sealed class ServiceProviderEngineScope : IServiceScope, IServiceProvider, IAsyncDisposable, IServiceScopeFactory
     {
         // For testing only
-        internal Action<object> _captureDisposableCallback;
+        internal IList<object> Disposables => _disposables ?? (IList<object>)Array.Empty<object>();
 
         private bool _disposed;
         private List<object> _disposables;
@@ -49,8 +49,6 @@ public object GetService(Type serviceType)
 
         internal object CaptureDisposable(object service)
         {
-            _captureDisposableCallback?.Invoke(service);
-
             if (ReferenceEquals(this, service) || !(service is IDisposable || service is IAsyncDisposable))
             {
                 return service;

src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/CallSiteTests.cs

@@ -135,16 +135,13 @@ public void BuildExpressionAddsDisposableCaptureForDisposableServices(ServiceLif
 
             var disposables = new List<object>();
             var provider = new ServiceProvider(descriptors, ServiceProviderOptions.Default);
-            provider.Root._captureDisposableCallback = obj =>
-            {
-                disposables.Add(obj);
-            };
+
             var callSite = provider.CallSiteFactory.GetCallSite(typeof(ServiceC), new CallSiteChain());
             var compiledCallSite = CompileCallSite(callSite, provider);
 
             var serviceC = (DisposableServiceC)compiledCallSite(provider.Root);
 
-            Assert.Equal(3, disposables.Count);
+            Assert.Equal(3, provider.Root.Disposables.Count);
         }
 
         [Theory]
@@ -161,16 +158,13 @@ public void BuildExpressionAddsDisposableCaptureForDisposableFactoryServices(Ser
 
             var disposables = new List<object>();
             var provider = new ServiceProvider(descriptors, ServiceProviderOptions.Default);
-            provider.Root._captureDisposableCallback = obj =>
-            {
-                disposables.Add(obj);
-            };
+
             var callSite = provider.CallSiteFactory.GetCallSite(typeof(ServiceC), new CallSiteChain());
             var compiledCallSite = CompileCallSite(callSite, provider);
 
             var serviceC = (DisposableServiceC)compiledCallSite(provider.Root);
 
-            Assert.Equal(3, disposables.Count);
+            Assert.Equal(3, provider.Root.Disposables.Count);
         }
 
         [Theory]
@@ -190,16 +184,13 @@ public void BuildExpressionElidesDisposableCaptureForNonDisposableServices(Servi
 
             var disposables = new List<object>();
             var provider = new ServiceProvider(descriptors, ServiceProviderOptions.Default);
-            provider.Root._captureDisposableCallback = obj =>
-            {
-                disposables.Add(obj);
-            };
+
             var callSite = provider.CallSiteFactory.GetCallSite(typeof(ServiceC), new CallSiteChain());
             var compiledCallSite = CompileCallSite(callSite, provider);
 
             var serviceC = (ServiceC)compiledCallSite(provider.Root);
 
-            Assert.Empty(disposables);
+            Assert.Empty(provider.Root.Disposables);
         }
 
         [Theory]
@@ -215,16 +206,13 @@ public void BuildExpressionElidesDisposableCaptureForEnumerableServices(ServiceL
 
             var disposables = new List<object>();
             var provider = new ServiceProvider(descriptors, ServiceProviderOptions.Default);
-            provider.Root._captureDisposableCallback = obj =>
-            {
-                disposables.Add(obj);
-            };
+
             var callSite = provider.CallSiteFactory.GetCallSite(typeof(ServiceD), new CallSiteChain());
             var compiledCallSite = CompileCallSite(callSite, provider);
 
             var serviceD = (ServiceD)compiledCallSite(provider.Root);
 
-            Assert.Empty(disposables);
+            Assert.Empty(provider.Root.Disposables);
         }
 
         [Fact]

src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs

@@ -1119,27 +1119,36 @@ private void ScopedServiceResolvedFromSingletonAfterCompilation2(ServiceProvider
             var scope = sp.CreateScope();
             for (int i = 0; i < 50; i++)
             {
-                Assert.Same(sp.GetRequiredService<IFakeOpenGenericService<A>>().Value, sp.GetRequiredService<A>());
+                scope.ServiceProvider.GetRequiredService<A>();
                 Thread.Sleep(10); // Give the background thread time to compile
             }
+
+            Assert.Same(sp.GetRequiredService<IFakeOpenGenericService<A>>().Value, sp.GetRequiredService<A>());
         }
 
-        [Fact]
-        public void ScopedServiceResolvedFromSingletonAfterCompilation3()
+        [Theory]
+        [InlineData(ServiceProviderMode.Default)]
+        [InlineData(ServiceProviderMode.Dynamic)]
+        [InlineData(ServiceProviderMode.Runtime)]
+        [InlineData(ServiceProviderMode.Expressions)]
+        [InlineData(ServiceProviderMode.ILEmit)]
+        private void ScopedServiceResolvedFromSingletonAfterCompilation3(ServiceProviderMode mode)
         {
             // Singleton IFakeX<A> -> Scoped A -> Scoped Aa
             ServiceProvider sp = new ServiceCollection()
                                 .AddScoped<Aa>()
                                 .AddScoped<A>()
                                 .AddSingleton<IFakeOpenGenericService<Aa>, FakeOpenGenericService<Aa>>()
-                                .BuildServiceProvider(ServiceProviderMode.ILEmit);
+                                .BuildServiceProvider(mode);
 
             var scope = sp.CreateScope();
             for (int i = 0; i < 50; i++)
             {
-                Assert.Same(sp.GetRequiredService<IFakeOpenGenericService<Aa>>().Value.PropertyA, sp.GetRequiredService<A>());
+                scope.ServiceProvider.GetRequiredService<A>();
                 Thread.Sleep(10); // Give the background thread time to compile
             }
+
+            Assert.Same(sp.GetRequiredService<IFakeOpenGenericService<Aa>>().Value.PropertyA, sp.GetRequiredService<A>());
         }
 
         private async Task<bool> ResolveUniqueServicesConcurrently()