Add UseFriendlyObjectDisposedException option (#87)

.github/codecov.yml

@@ -0,0 +1,3 @@
+# https://docs.codecov.com/docs/codecov-yaml
+comment:
+  behavior: new

.github/workflows/label.yml

@@ -6,7 +6,10 @@
 # https://github.com/actions/labeler/blob/master/README.md
 
 name: Labeler
-on: [pull_request]
+on:
+  pull_request_target:
+    types:
+      - opened        # when PR is opened
 
 jobs:
   label:

src/Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 
   <PropertyGroup>
-    <VersionPrefix>1.0.2-preview</VersionPrefix>
+    <VersionPrefix>1.0.3-preview</VersionPrefix>
     <LangVersion>latest</LangVersion>
     <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>

src/SteroidsDI.Tests/Cases.Approval/SteroidsDI.approved.txt

@@ -37,6 +37,7 @@ namespace SteroidsDI
     {
         public ServiceProviderAdvancedOptions() { }
         public bool AllowRootProviderResolve { get; set; }
+        public bool UseFriendlyObjectDisposedException { get; set; }
         public bool ValidateParallelScopes { get; set; }
     }
 }

src/SteroidsDI.Tests/Cases/AllowRootProviderResolveTests.cs

@@ -28,9 +28,9 @@ public void Should_Work_When_No_Scopes_And_AllowRootProviderResolve_Enabled()
            .AddSingleton<ScopedAsSingleton>()
            .AddSingleton<Service>();
 
-        using (var provider = services.BuildServiceProvider())
+        using (var rootProvider = services.BuildServiceProvider())
         {
-            using (var scope = provider.CreateScope())
+            using (var scope = rootProvider.CreateScope())
             {
                 var service = scope.ServiceProvider.GetService<Service>()!;
                 service.Scoped.Value.ShouldNotBeNull();
@@ -48,9 +48,9 @@ public void Should_Throw_When_No_Scopes_And_AllowRootProviderResolve_Disabled()
            .AddSingleton<ScopedAsSingleton>()
            .AddSingleton<Service>();
 
-        using (var provider = services.BuildServiceProvider())
+        using (var rootProvider = services.BuildServiceProvider())
         {
-            using (var scope = provider.CreateScope())
+            using (var scope = rootProvider.CreateScope())
             {
                 var service = scope.ServiceProvider.GetService<Service>()!;
                 Should.Throw<InvalidOperationException>(() => service.Scoped.Value).Message.ShouldBe(@"The current scope is missing. Unable to resolve service 'ScopedAsSingleton' from the root service provider.
@@ -69,9 +69,9 @@ public void Should_Throw_When_No_Scopes_And_No_Service_Registered_And_AllowRootP
            .AddDefer()
            .AddSingleton<Service>();
 
-        using (var provider = services.BuildServiceProvider())
+        using (var rootProvider = services.BuildServiceProvider())
         {
-            using (var scope = provider.CreateScope())
+            using (var scope = rootProvider.CreateScope())
             {
                 var service = scope.ServiceProvider.GetService<Service>()!;
                 Should.Throw<InvalidOperationException>(() => service.Scoped.Value).Message.ShouldBe("No service for type 'SteroidsDI.Tests.Cases.AllowRootProviderResolveTests+ScopedAsSingleton' has been registered.");

src/SteroidsDI.Tests/Cases/AspNetCoreHttpScopeProviderTests.cs

@@ -19,26 +19,26 @@ public void Should_Throw_If_Called_With_Null_Provider()
     [Test]
     public void Should_Return_Null_If_Called_Out_Of_HttpContext()
     {
-        var provider = new ServiceCollection().AddHttpScope().BuildServiceProvider();
-        new AspNetCoreHttpScopeProvider().GetScopedServiceProvider(provider).ShouldBe(null);
+        var rootProvider = new ServiceCollection().AddHttpScope().BuildServiceProvider();
+        new AspNetCoreHttpScopeProvider().GetScopedServiceProvider(rootProvider).ShouldBe(null);
     }
 
     [Test]
     public void Should_Return_Null_If_Called_With_HttpContext_Without_Provider()
     {
-        var provider = new ServiceCollection().AddHttpScope().BuildServiceProvider();
+        var rootProvider = new ServiceCollection().AddHttpScope().BuildServiceProvider();
         new HttpContextAccessor().HttpContext = new DefaultHttpContext();
-        new AspNetCoreHttpScopeProvider().GetScopedServiceProvider(provider).ShouldBeNull();
+        new AspNetCoreHttpScopeProvider().GetScopedServiceProvider(rootProvider).ShouldBeNull();
     }
 
     [Test]
     public void Should_Return_Provider_If_Called_With_HttpContext_With_Provider()
     {
-        var provider = new ServiceCollection().AddHttpScope().BuildServiceProvider();
+        var rootProvider = new ServiceCollection().AddHttpScope().BuildServiceProvider();
         new HttpContextAccessor().HttpContext = new DefaultHttpContext()
         {
             RequestServices = new ServiceCollection().BuildServiceProvider()
         };
-        new AspNetCoreHttpScopeProvider().GetScopedServiceProvider(provider).ShouldNotBeNull();
+        new AspNetCoreHttpScopeProvider().GetScopedServiceProvider(rootProvider).ShouldNotBeNull();
     }
 }

src/SteroidsDI.Tests/Cases/UseFriendlyObjectDisposedExceptionTests.cs

@@ -0,0 +1,95 @@
+using Microsoft.Extensions.DependencyInjection;
+using NUnit.Framework;
+using Shouldly;
+using SteroidsDI.Core;
+
+namespace SteroidsDI.Tests.Cases;
+
+internal class UseFriendlyObjectDisposedExceptionTests
+{
+    [Test]
+    public void ObjectDisposedException_UseFriendlyObjectDisposedException_Enabled()
+    {
+        var services = new ServiceCollection()
+            .AddDefer()
+            .AddScoped<ScopedService>()
+            .AddSingleton<SingletonService>()
+            .AddGenericScope<UseFriendlyObjectDisposedExceptionTests>();
+
+        using (var rootProvider = services.BuildServiceProvider())
+        {
+            var service = rootProvider.GetRequiredService<SingletonService>();
+            var outerScope = new Scoped<UseFriendlyObjectDisposedExceptionTests>(rootProvider.GetRequiredService<IScopeFactory>());
+
+            var cts1 = new CancellationTokenSource();
+            var cts2 = new CancellationTokenSource();
+
+            var t = Task.Run(() =>
+            {
+                cts1.Cancel();
+                cts2.Token.WaitHandle.WaitOne();
+
+                var ex = Should.Throw<ObjectDisposedException>(() => service.Scoped.Value);
+                ex.Message.ShouldBe(@"ObjectDisposedException occurred while resolving service 'ScopedService' by scoped service provider obtained from 'SteroidsDI.GenericScopeProvider`1[[SteroidsDI.Tests.Cases.UseFriendlyObjectDisposedExceptionTests, SteroidsDI.Tests, Version=1.0.3.0, Culture=neutral, PublicKeyToken=null]]'.
+Most likely this happened because the scope and scoped provider were disposed BEFORE the actual completion of the user code.
+Often, this is due to a forgotten 'await' operator somewhere in the user code. Make sure you await all the created tasks correctly.
+You see this message because 'ServiceProviderAdvancedOptions.UseFriendlyObjectDisposedException' option is enabled.");
+                ex.InnerException.ShouldBeOfType<ObjectDisposedException>().Message.ShouldBe(@"Cannot access a disposed object.
+Object name: 'IServiceProvider'.");
+            });
+
+            cts1.Token.WaitHandle.WaitOne();
+            outerScope.Dispose();
+            cts2.Cancel();
+            t.Wait();
+        }
+    }
+
+    [Test]
+    public void ObjectDisposedException_UseFriendlyObjectDisposedException_Disabled()
+    {
+        var services = new ServiceCollection()
+            .Configure<ServiceProviderAdvancedOptions>(opt => opt.UseFriendlyObjectDisposedException = false)
+            .AddDefer()
+            .AddScoped<ScopedService>()
+            .AddSingleton<SingletonService>()
+            .AddGenericScope<UseFriendlyObjectDisposedExceptionTests>();
+
+        using (var rootProvider = services.BuildServiceProvider())
+        {
+            var service = rootProvider.GetRequiredService<SingletonService>();
+            var outerScope = new Scoped<UseFriendlyObjectDisposedExceptionTests>(rootProvider.GetRequiredService<IScopeFactory>());
+
+            var cts1 = new CancellationTokenSource();
+            var cts2 = new CancellationTokenSource();
+
+            var t = Task.Run(() =>
+            {
+                cts1.Cancel();
+                cts2.Token.WaitHandle.WaitOne();
+
+                var ex = Should.Throw<ObjectDisposedException>(() => service.Scoped.Value);
+                ex.Message.ShouldBe(@"Cannot access a disposed object.
+Object name: 'IServiceProvider'.");
+                ex.InnerException.ShouldBeNull();
+            });
+
+            cts1.Token.WaitHandle.WaitOne();
+            outerScope.Dispose();
+            cts2.Cancel();
+            t.Wait();
+        }
+    }
+
+    private sealed class ScopedService { }
+
+    private class SingletonService
+    {
+        public SingletonService(IDefer<ScopedService> scoped)
+        {
+            Scoped = scoped;
+        }
+
+        public IDefer<ScopedService> Scoped { get; }
+    }
+}

src/SteroidsDI.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.29519.181
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32228.430
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5507BC57-E2E4-4AA9-A385-6571387E1387}"
 	ProjectSection(SolutionItems) = preProject
@@ -26,6 +26,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Example", "Example\Example.
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{AE542B88-FDC2-4331-9D90-AB458D7BDFF9}"
 	ProjectSection(SolutionItems) = preProject
+		..\.github\codecov.yml = ..\.github\codecov.yml
 		..\.github\dependabot.yml = ..\.github\dependabot.yml
 		..\.github\FUNDING.yml = ..\.github\FUNDING.yml
 		..\.github\labeler.yml = ..\.github\labeler.yml

src/SteroidsDI/Resolver.cs

@@ -50,7 +50,17 @@ internal static object Resolve(this IServiceProvider rootProvider, Type type, Se
                     }
                 }
 
-                return scopedServiceProvider.GetRequiredService(type);
+                try
+                {
+                    return scopedServiceProvider.GetRequiredService(type);
+                }
+                catch (ObjectDisposedException e) when (options.UseFriendlyObjectDisposedException)
+                {
+                    throw new ObjectDisposedException($@"ObjectDisposedException occurred while resolving service '{type.Name}' by scoped service provider obtained from '{scopeProvider.GetType().FullName}'.
+Most likely this happened because the scope and scoped provider were disposed BEFORE the actual completion of the user code.
+Often, this is due to a forgotten 'await' operator somewhere in the user code. Make sure you await all the created tasks correctly.
+You see this message because 'ServiceProviderAdvancedOptions.UseFriendlyObjectDisposedException' option is enabled.", e);
+                }
             }
         }
 

src/SteroidsDI/ServiceProviderAdvancedOptions.cs

@@ -8,15 +8,28 @@ namespace SteroidsDI;
 public sealed class ServiceProviderAdvancedOptions
 {
     /// <summary>
-    /// <see langword="true"/> to validate the situation with the presence of parallel
-    /// scopes from different providers. The situation is unlikely but may arise.
+    /// Set this option to <see langword="false"/> to disable wrapping original <see cref="ObjectDisposedException"/>
+    /// thrown from <see cref="IServiceProvider.GetService(Type)"/>. In most cases, the initial error message is in
+    /// little informative and the developer does not understand what is happening and what he should do to fix the error.
+    /// <br/>
+    /// Defaults to <see langword="true"/>.
+    /// </summary>
+    public bool UseFriendlyObjectDisposedException { get; set; } = true;
+
+    /// <summary>
+    /// Set this option to <see langword="true"/> to validate the situation with the presence
+    /// of parallel scopes from different providers. The situation is unlikely but may arise.
+    /// <br/>
+    /// Defaults to <see langword="false"/>.
     /// </summary>
     public bool ValidateParallelScopes { get; set; }
 
     /// <summary>
-    /// Allows resolving objects through the root provider if the current scope is missing.
-    /// The object must have lifetime different from scoped. Getting scoped objects through
-    /// the root provider is ALWAYS FORBIDDEN. Defaults to <see langword="false"/>.
+    /// Set this option to <see langword="true"/> to allow resolving objects through the root
+    /// provider if the current scope is missing. The object must have lifetime different from
+    /// scoped. Getting scoped objects through the root provider is ALWAYS FORBIDDEN.
+    /// <br/>
+    /// Defaults to <see langword="false"/>.
     /// </summary>
     public bool AllowRootProviderResolve { get; set; }