Breaking change: Throw when resolving on a disposed service provider

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

@@ -17,6 +17,7 @@ internal class ServiceProviderEngineScope : IServiceScope, IServiceProvider, IAs
         private List<object> _disposables;
 
         private bool _disposed;
+        private object _lock = new object();
 
         public ServiceProviderEngineScope(ServiceProviderEngine engine)
         {
@@ -41,17 +42,27 @@ public object GetService(Type serviceType)
 
         internal object CaptureDisposable(object service)
         {
-            Debug.Assert(!_disposed);
-
             _captureDisposableCallback?.Invoke(service);
 
             if (ReferenceEquals(this, service) || !(service is IDisposable || service is IAsyncDisposable))
             {
                 return service;
             }
 
-            lock (ResolvedServices)
+            lock (_lock)
             {
+                if (_disposed)
+                {
+                    if (service is IDisposable disposable)
+                    {
+                        disposable.Dispose();
+                    }
+                    else
+                    {
+                        ((IAsyncDisposable)service).DisposeAsync().AsTask().GetAwaiter().GetResult();
+                    }
+                    ThrowHelper.ThrowObjectDisposedException();
+                }
                 if (_disposables == null)
                 {
                     _disposables = new List<object>();
@@ -144,7 +155,7 @@ static async ValueTask Await(int i, ValueTask vt, List<object> toDispose)
         private List<object> BeginDispose()
         {
             List<object> toDispose;
-            lock (ResolvedServices)
+            lock (_lock)
             {
                 if (_disposed)
                 {

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

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection.Fakes;
 using Microsoft.Extensions.DependencyInjection.Specification;
@@ -265,6 +266,79 @@ public void ScopeDispose_PreventsServiceResolution()
             Assert.NotNull(provider.CreateScope());
         }
 
+        [Fact]
+        public void GetService_ThenDisposeOnDifferentThread_ServiceDisposed()
+        {
+            var services = new ServiceCollection();
+            services.AddSingleton<Foo1>();
+            var sp = services.BuildServiceProvider();
+            var foo = sp.GetRequiredService<Foo1>();
+            Task.Run(() => sp.Dispose()).Wait();
+
+            Assert.True(foo.IsDisposed);
+        }
+
+        [Fact]
+        public void GetService_DisposeOnSameThread_Throws()
+        {
+            var services = new ServiceCollection();
+            services.AddSingleton<Foo2>();
+            var sp = services.BuildServiceProvider();
+            Assert.Throws<ObjectDisposedException>(() =>
+            {
+                // ctor disposes ServiceProvider
+                var foo = sp.GetRequiredService<Foo2>();
+            });
+        }
+
+        [Fact]
+        public void GetAsyncService_DisposeAsyncOnSameThread_Throws()
+        {
+            var services = new ServiceCollection();
+            services.AddSingleton<FooAsyncDisposable>();
+            var sp = services.BuildServiceProvider();
+            Assert.Throws<ObjectDisposedException>(() =>
+            {
+                // ctor disposes ServiceProvider
+                var foo = sp.GetRequiredService<FooAsyncDisposable>();
+            });
+        }
+
+        private class Foo1 : IDisposable
+        {
+            public Foo1()
+            {
+                Thread.Sleep(5000);
+            }
+            public bool IsDisposed { get; private set; }
+
+            public void Dispose()
+            {
+                IsDisposed = true;
+            }
+        }
+
+        private class Foo2 : IDisposable
+        {
+            public Foo2(IServiceProvider sp)
+            {
+                (sp as IDisposable).Dispose();
+            }
+            public void Dispose() { }
+        }
+
+        private class FooAsyncDisposable : IFakeService, IAsyncDisposable
+        {
+            public FooAsyncDisposable(IServiceProvider sp)
+            {
+                (sp as IDisposable).Dispose();
+            }
+            public ValueTask DisposeAsync()
+            {
+                return new ValueTask(Task.CompletedTask);
+            }
+        }
+
         [ActiveIssue("https://github.com/dotnet/runtime/issues/42160")] // We don't support value task services currently
         [Theory]
         [InlineData(ServiceLifetime.Transient)]