Fixed bug in missing root scope with orleans/kestrel.

The previous handling of root scope is wrong, the code
set root scope in an AsyncLocal variable when WindsorServiceProviderFactoryBase
was first creatd. The problem arise with kestrel or orleans in
.NET 8, they use a Thread Pool that runs code outside AsyncLocal
so it will break resolution.
It was not possible to reproduce locally, but it was reproduced
with production code. A repro for the bug still missing.
Also we can support using a Global root scope only if we use
only ONE CONTAINER in the .NET core DI, because basic structure
does not allow to find the container that is resolving scoped component
thus we cannot determin the right root context.
Still work to do to support multiple container.

Author: alkampfergit

src/Castle.Windsor.Extensions.DependencyInjection.Tests/CustomAssumptionTests.cs

@@ -1,7 +1,10 @@
 #if NET8_0_OR_GREATER
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Specification.Fakes;
 using System;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Castle.Windsor.Extensions.DependencyInjection.Tests
@@ -36,28 +39,232 @@ public void Resolve_All()
 			Assert.IsType<AnotherTestService>(keyedServices.Last());
 		}
 
+		[Fact]
+		public void Scoped_keyed_service_resolved_by_thread_outside_scope()
+		{
+			Boolean stop = false;
+			Boolean shouldResolve = false;
+			ITestService resolvedInThread = null;
+			var thread = new Thread(_ =>
+			{
+				while (!stop)
+				{
+					Thread.Sleep(100);
+					if (shouldResolve)
+					{
+						stop = true;
+						resolvedInThread = _serviceProvider.GetRequiredKeyedService<ITestService>("porcodio");
+					}
+				}
+			});
+			thread.Start();
+
+			var serviceCollection = GetServiceCollection();
+			serviceCollection.AddKeyedScoped<ITestService, TestService>("porcodio");
+			_serviceProvider = BuildServiceProvider(serviceCollection);
+
+			//resolved outside scope
+			ITestService resolvedOutsideScope = _serviceProvider.GetRequiredKeyedService<ITestService>("porcodio");
+
+			// resolve in scope
+			ITestService resolvedInScope;
+			using (var scope = _serviceProvider.CreateScope())
+			{
+				resolvedInScope = scope.ServiceProvider.GetRequiredKeyedService<ITestService>("porcodio");
+			}
+
+			shouldResolve = true;
+			//now wait for the original thread to finish
+			thread.Join(1000 * 10);
+			Assert.NotNull(resolvedInThread);
+			Assert.NotNull(resolvedOutsideScope);
+			Assert.NotNull(resolvedInScope);
+
+			Assert.NotEqual(resolvedInScope, resolvedOutsideScope);
+			Assert.NotEqual(resolvedInScope, resolvedInThread);
+			Assert.Equal(resolvedOutsideScope, resolvedInThread);
+		}
+
+		[Fact]
+		public void Scoped_service_resolved_outside_scope()
+		{
+			var serviceCollection = GetServiceCollection();
+			serviceCollection.AddScoped<ITestService, TestService>();
+			_serviceProvider = BuildServiceProvider(serviceCollection);
+
+			//resolved outside scope
+			ITestService resolvedOutsideScope = _serviceProvider.GetRequiredService<ITestService>();
+			Assert.NotNull(resolvedOutsideScope);
+
+			// resolve in scope
+			ITestService resolvedInScope;
+			using (var scope = _serviceProvider.CreateScope())
+			{
+				resolvedInScope = scope.ServiceProvider.GetRequiredService<ITestService>();
+			}
+			Assert.NotNull(resolvedInScope);
+			Assert.NotEqual(resolvedInScope, resolvedOutsideScope);
+
+			ITestService resolvedAgainOutsideScope = _serviceProvider.GetRequiredService<ITestService>();
+			Assert.NotNull(resolvedAgainOutsideScope);
+			Assert.Equal(resolvedOutsideScope, resolvedAgainOutsideScope);
+		}
+
+		[Fact]
+		public void Scoped_service_resolved_outside_scope_in_another_thread()
+		{
+			var serviceCollection = GetServiceCollection();
+			serviceCollection.AddScoped<ITestService, TestService>();
+			_serviceProvider = BuildServiceProvider(serviceCollection);
+
+			var task = Task.Run(() =>
+			{
+				//resolved outside scope
+				ITestService resolvedOutsideScope = _serviceProvider.GetRequiredService<ITestService>();
+				Assert.NotNull(resolvedOutsideScope);
+
+				// resolve in scope
+				ITestService resolvedInScope;
+				using (var scope = _serviceProvider.CreateScope())
+				{
+					resolvedInScope = scope.ServiceProvider.GetRequiredService<ITestService>();
+				}
+				Assert.NotNull(resolvedInScope);
+				Assert.NotEqual(resolvedInScope, resolvedOutsideScope);
+
+				ITestService resolvedAgainOutsideScope = _serviceProvider.GetRequiredService<ITestService>();
+				Assert.NotNull(resolvedAgainOutsideScope);
+				Assert.Equal(resolvedOutsideScope, resolvedAgainOutsideScope);
+				return true;
+			});
+
+			Assert.True(task.Result);
+		}
+
+		[Fact]
+		public async void Scoped_service_resolved_outside_scope_in_another_unsafe_thread()
+		{
+			var serviceCollection = GetServiceCollection();
+			serviceCollection.AddScoped<ITestService, TestService>();
+			_serviceProvider = BuildServiceProvider(serviceCollection);
+
+			var tsc = new TaskCompletionSource();
+			var worker = new QueueUserWorkItemWorker(_serviceProvider, tsc);
+			ThreadPool.UnsafeQueueUserWorkItem(worker, false);
+			await tsc.Task;
+
+			Assert.Null(worker.ExecuteException);
+			Assert.NotNull(worker.ResolvedOutsideScope);
+			Assert.NotNull(worker.ResolvedInScope);
+			Assert.NotEqual(worker.ResolvedInScope, worker.ResolvedOutsideScope);
+		}
+
+		[Fact]
+		public async void Simulate_async_timer_without_wait()
+		{
+			Boolean stop = false;
+			Boolean shouldResolve = false;
+			ITestService resolvedInThread = null;
+			async Task ExecuteAsync()
+			{
+				while (!stop)
+				{
+					await Task.Delay(100);
+					if (shouldResolve)
+					{
+						stop = true;
+						resolvedInThread = _serviceProvider.GetService<ITestService>();
+					}
+				}
+			}
+			//fire and forget
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+			var task = ExecuteAsync();
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
+			await Task.Delay(500);
+
+			var serviceCollection = GetServiceCollection();
+			serviceCollection.AddScoped<ITestService, TestService>();
+			_serviceProvider = BuildServiceProvider(serviceCollection);
+
+			//resolved outside scope
+			ITestService resolvedOutsideScope = _serviceProvider.GetRequiredService<ITestService>();
+
+			// resolve in scope
+			ITestService resolvedInScope;
+			using (var scope = _serviceProvider.CreateScope())
+			{
+				resolvedInScope = scope.ServiceProvider.GetRequiredService<ITestService>();
+			}
+
+			shouldResolve = true;
+			await task;
+			Assert.NotNull(resolvedInThread);
+			Assert.NotNull(resolvedOutsideScope);
+			Assert.NotNull(resolvedInScope);
+
+			Assert.NotEqual(resolvedInScope, resolvedOutsideScope);
+			Assert.NotEqual(resolvedInScope, resolvedInThread);
+			Assert.Equal(resolvedOutsideScope, resolvedInThread);
+		}
+
+		private class QueueUserWorkItemWorker : IThreadPoolWorkItem
+		{
+			private readonly IServiceProvider _provider;
+			private readonly TaskCompletionSource _taskCompletionSource;
+
+			public QueueUserWorkItemWorker(IServiceProvider provider, TaskCompletionSource taskCompletionSource)
+			{
+				_provider = provider;
+				_taskCompletionSource = taskCompletionSource;
+			}
+
+			public ITestService ResolvedOutsideScope { get; private set; }
+			public ITestService ResolvedInScope { get; private set; }
+			public Exception ExecuteException { get; private set; }
+
+			public void Execute()
+			{
+				try
+				{
+					ResolvedOutsideScope = _provider.GetService<ITestService>();
+					using (var scope = _provider.CreateScope())
+					{
+						ResolvedInScope = scope.ServiceProvider.GetRequiredService<ITestService>();
+					}
+				}
+				catch (Exception ex)
+				{
+					ExecuteException = ex;
+				}
+
+				_taskCompletionSource.SetResult();
+			}
+		}
+
 		protected abstract IServiceCollection GetServiceCollection();
 
 		protected abstract IServiceProvider BuildServiceProvider(IServiceCollection serviceCollection);
 
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                // Dispose managed resources
-                if (_serviceProvider is IDisposable disposable)
-                {
-                    disposable.Dispose();
-                }
-            }
-            // Dispose unmanaged resources
-        }
+		public void Dispose()
+		{
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		protected virtual void Dispose(bool disposing)
+		{
+			if (disposing)
+			{
+				// Dispose managed resources
+				if (_serviceProvider is IDisposable disposable)
+				{
+					disposable.Dispose();
+				}
+			}
+			// Dispose unmanaged resources
+		}
 	}
 
 	public class RealCustomAssumptionTests : CustomAssumptionTests
@@ -75,6 +282,8 @@ protected override IServiceProvider BuildServiceProvider(IServiceCollection serv
 
 	public class CastleWindsorCustomAssumptionTests : CustomAssumptionTests
 	{
+		private IWindsorContainer _container;
+
 		protected override IServiceCollection GetServiceCollection()
 		{
 			return new TestServiceCollection();
@@ -83,8 +292,64 @@ protected override IServiceCollection GetServiceCollection()
 		protected override IServiceProvider BuildServiceProvider(IServiceCollection serviceCollection)
 		{
 			var factory = new WindsorServiceProviderFactory();
-			var container = factory.CreateBuilder(serviceCollection);
-			return factory.CreateServiceProvider(container);
+			_container = factory.CreateBuilder(serviceCollection);
+			return factory.CreateServiceProvider(_container);
+		}
+
+		[Fact]
+		public void Try_to_resolve_scoped_directly_with_castle_windsor_container()
+		{
+			var serviceCollection = GetServiceCollection();
+			serviceCollection.AddScoped<ITestService, TestService>();
+			var provider = BuildServiceProvider(serviceCollection);
+
+			//resolved outside scope
+			ITestService resolvedOutsideScope = _container.Resolve<ITestService>();
+			Assert.NotNull(resolvedOutsideScope);
+
+			// resolve in scope
+			ITestService resolvedInScope;
+			using (var scope = provider.CreateScope())
+			{
+				resolvedInScope = _container.Resolve<ITestService>();
+			}
+			Assert.NotNull(resolvedInScope);
+			Assert.NotEqual(resolvedInScope, resolvedOutsideScope);
+
+			ITestService resolvedAgainOutsideScope = _container.Resolve<ITestService>();
+			Assert.NotNull(resolvedAgainOutsideScope);
+			Assert.Equal(resolvedOutsideScope, resolvedAgainOutsideScope);
+		}
+
+		[Fact]
+		public void TryToResolveScopedInOtherThread()
+		{
+			var serviceCollection = GetServiceCollection();
+			serviceCollection.AddScoped<ITestService, TestService>();
+			var provider = BuildServiceProvider(serviceCollection);
+
+			var task = Task.Run(() =>
+			{
+				//resolved outside scope
+				ITestService resolvedOutsideScope = _container.Resolve<ITestService>();
+				Assert.NotNull(resolvedOutsideScope);
+
+				// resolve in scope
+				ITestService resolvedInScope;
+				using (var scope = provider.CreateScope())
+				{
+					resolvedInScope = _container.Resolve<ITestService>();
+				}
+				Assert.NotNull(resolvedInScope);
+				Assert.NotEqual(resolvedInScope, resolvedOutsideScope);
+
+				ITestService resolvedAgainOutsideScope = _container.Resolve<ITestService>();
+				Assert.NotNull(resolvedAgainOutsideScope);
+				Assert.Equal(resolvedOutsideScope, resolvedAgainOutsideScope);
+				return true;
+			});
+
+			Assert.True(task.Result);
 		}
 	}
 

src/Castle.Windsor.Extensions.DependencyInjection.Tests/ResolveFromThreadpoolUnsafe.cs

@@ -1,4 +1,5 @@
-using Castle.MicroKernel.Lifestyle;
+using Castle.MicroKernel;
+using Castle.MicroKernel.Lifestyle;
 using Castle.MicroKernel.Registration;
 using Castle.Windsor.Extensions.DependencyInjection.Extensions;
 using Castle.Windsor.Extensions.DependencyInjection.Tests.Components;
@@ -512,8 +513,8 @@ public async Task Cannot_Resolve_LifestyleScopedToNetServiceScope_From_WindsorCo
 			});
 
 			Assert.NotNull(ex);
-			Assert.IsType<InvalidOperationException>(ex);
-			Assert.StartsWith("No scope available", ex.Message);
+			Assert.IsType<ComponentResolutionException>(ex);
+			Assert.StartsWith("Could not obtain scope for component", ex.Message);
 
 			(sp as IDisposable)?.Dispose();
 			container.Dispose();
@@ -711,8 +712,8 @@ public async Task Cannot_Resolve_LifestyleNetTransient_From_WindsorContainer_NoS
 			});
 
 			Assert.NotNull(ex);
-			Assert.IsType<InvalidOperationException>(ex);
-			Assert.StartsWith("No scope available", ex.Message);
+			Assert.IsType<ComponentResolutionException>(ex);
+			Assert.StartsWith("Could not obtain scope for component", ex.Message);
 
 			(sp as IDisposable)?.Dispose();
 			container.Dispose();

src/Castle.Windsor.Extensions.DependencyInjection/Resolvers/LoggerDependencyResolver.cs

@@ -18,7 +18,7 @@ namespace Castle.Windsor.Extensions.DependencyInjection.Resolvers
 	using Castle.Core;
 	using Castle.MicroKernel;
 	using Castle.MicroKernel.Context;
-	
+
 	using Microsoft.Extensions.Logging;
 
 	public class LoggerDependencyResolver : ISubDependencyResolver