Breaking change: Throw when resolving on a disposed service provider

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

@@ -17,7 +17,7 @@ internal class ServiceProviderEngineScope : IServiceScope, IServiceProvider, IAs
         private List<object> _disposables;
 
         private bool _disposed;
-        private static object s_locker = new object();
+        private object _locker = new object();
 
         public ServiceProviderEngineScope(ServiceProviderEngine engine)
         {
@@ -49,7 +49,7 @@ internal object CaptureDisposable(object service)
                 return service;
             }
 
-            lock (s_locker)
+            lock (_locker)
             {
                 if (_disposed)
                 {
@@ -152,7 +152,7 @@ static async ValueTask Await(int i, ValueTask vt, List<object> toDispose)
         private List<object> BeginDispose()
         {
             List<object> toDispose;
-            lock (s_locker)
+            lock (_locker)
             {
                 if (_disposed)
                 {

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

@@ -6,7 +6,6 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Fakes;
 using Microsoft.Extensions.DependencyInjection.Specification;
 using Microsoft.Extensions.DependencyInjection.Specification.Fakes;
@@ -266,55 +265,62 @@ public void ScopeDispose_PreventsServiceResolution()
             //Check that resolution from root works
             Assert.NotNull(provider.CreateScope());
         }
-
-        [ThreadStatic]
-        public static int ThreadId;
 
         [Fact]
-        public async Task ServiceProviderDispose_ContinueResolvingServices_Throws()
+        private void GetService_ThenDisposeOnDifferentThread_ServiceDisposed()
         {
             var services = new ServiceCollection();
-            ServiceProvider sp = null;
+            services.AddSingleton<Foo>();
+            var sp = services.BuildServiceProvider();
+            var foo = sp.GetRequiredService<Foo>();
+            Task.Run(() => sp.Dispose()).Wait();
+
+            Assert.Equal(
+                Foo.TimesConstructorCalled,
+                Foo.TimesDisposeCalled);
+        }
 
-            var lazy = new Lazy<Thing1>(() =>
+        [Fact]
+        public void GetService_DisposeOnSameThread_Throws()
+        {
+            var services = new ServiceCollection();
+            services.AddSingleton<DisposableFoo>();
+            var sp = services.BuildServiceProvider();
+            Assert.Throws<ObjectDisposedException>(() =>
             {
-                // Tries to take the singleton lock (global)
-                return new Thing1(sp);
+                // foo ctor disposes ServiceProvider
+                var foo = sp.GetRequiredService<DisposableFoo>();
             });
+        }
 
-            services.AddTransient(sp =>
+        public class Foo : IDisposable
+        {
+            public static int TimesConstructorCalled = 0;
+            public static int TimesDisposeCalled = 0;
+            public Foo()
             {
-                if (ThreadId == 1)
-                {
-                    Thread.Sleep(1000);
-                }
-                else
-                {
-                    // Let Thread 1 over take Thread 2
-                    Thread.Sleep(3000);
-                }
-
-                return lazy.Value;
-            });
-            services.AddSingleton<Thing2>();
-
-            sp = services.BuildServiceProvider();
-
-            var t1 = Task.Run(() =>
+                Interlocked.Increment(ref TimesConstructorCalled);
+                Thread.Sleep(5000);
+            }
+            public void Dispose()
             {
-                ThreadId = 1;
-                using var scope1 = sp.CreateScope();
-                scope1.ServiceProvider.GetRequiredService<Thing1>();
-            });
+                Interlocked.Increment(ref TimesDisposeCalled);
+            }
+        }
 
-           var t2 = Task.Run(() =>
+        public class DisposableFoo : IDisposable
+        {
+            public static int TimesConstructorCalled = 0;
+            public static int TimesDisposeCalled = 0;
+            public DisposableFoo(IServiceProvider sp)
             {
-                ThreadId = 2;
-                using var scope2 = sp.CreateScope();
-                scope2.ServiceProvider.GetRequiredService<Thing2>();
-            });
-
-            await Assert.ThrowsAsync<ObjectDisposedException>(async () => { await t1; await t2; });
+                Interlocked.Increment(ref TimesConstructorCalled);
+                (sp as IDisposable).Dispose();
+            }
+            public void Dispose()
+            {
+                Interlocked.Increment(ref TimesDisposeCalled);
+            }
         }
 
         public class Thing2 : IDisposable