Castle.Windsor.Extensions.DependencyInjection: support parallel containers (see #563)

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

@@ -0,0 +1,31 @@
+// Copyright 2004-2020 Castle Project - http://www.castleproject.org/
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Castle.Windsor.Extensions.DependencyInjection.Tests
+{
+	using System;
+
+	using Microsoft.Extensions.DependencyInjection;
+	using Microsoft.Extensions.DependencyInjection.Specification;
+
+	public class WindsorScopedServiceProviderCustomWindsorContainerTests : DependencyInjectionSpecificationTests
+	{
+		protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
+		{
+			var factory = new WindsorServiceProviderFactory(new WindsorContainer());
+			var container = factory.CreateBuilder(serviceCollection);
+			return factory.CreateServiceProvider(container);
+		}
+	}
+}

src/Castle.Windsor.Extensions.DependencyInjection/Scope/ExtensionContainerRootScope.cs

@@ -16,17 +16,15 @@ namespace Castle.Windsor.Extensions.DependencyInjection.Scope
 {
 	internal class ExtensionContainerRootScope : ExtensionContainerScope
 	{
-		internal static ExtensionContainerRootScope RootScope {get; private set;}
-		private ExtensionContainerRootScope() : base(null)
+		private ExtensionContainerRootScope() : base(null, null)
 		{
-
 		}
+
 		public static ExtensionContainerRootScope BeginRootScope()
 		{
 			var scope = new ExtensionContainerRootScope();
-			ExtensionContainerScope.current.Value = scope;
-			RootScope = scope;
+			current.Value = scope;
 			return scope;
 		}
 	}
-}
+}

src/Castle.Windsor.Extensions.DependencyInjection/Scope/ExtensionContainerRootScopeAccessor.cs

@@ -15,24 +15,29 @@
 namespace Castle.Windsor.Extensions.DependencyInjection.Scope
 {
 	using System;
-	
+
 	using Castle.MicroKernel.Context;
 	using Castle.MicroKernel.Lifestyle.Scoped;
 
 	internal class ExtensionContainerRootScopeAccessor : IScopeAccessor
 	{
 		public ILifetimeScope GetScope(CreationContext context)
 		{
-			if (ExtensionContainerRootScope.RootScope == null)
+			if (ExtensionContainerScope.Current == null)
+			{
+				throw new InvalidOperationException("No root scope");
+			}
+
+			if (ExtensionContainerScope.Current.RootScope == null)
 			{
 				throw new InvalidOperationException("No root scope");
 			}
 
-			return ExtensionContainerRootScope.RootScope;
+			return ExtensionContainerScope.Current.RootScope;
 		}
 
 		public void Dispose()
 		{
 		}
 	}
-}
+}

src/Castle.Windsor.Extensions.DependencyInjection/Scope/ExtensionContainerScope.cs

@@ -20,36 +20,38 @@ namespace Castle.Windsor.Extensions.DependencyInjection.Scope
 	using Castle.Core;
 	using Castle.MicroKernel;
 	using Castle.MicroKernel.Lifestyle.Scoped;
-	
+
 	internal class ExtensionContainerScope : ILifetimeScope, IDisposable
 	{
 		public static ExtensionContainerScope Current => current.Value;
 		public static string TransientMarker = "Transient";
 		protected static readonly AsyncLocal<ExtensionContainerScope> current = new AsyncLocal<ExtensionContainerScope>();
 		private readonly ExtensionContainerScope parent;
+		private readonly ExtensionContainerRootScope rootScope;
 		private readonly IScopeCache scopeCache;
 
-		protected ExtensionContainerScope(ExtensionContainerScope parent)
+		protected ExtensionContainerScope(
+			ExtensionContainerScope parent,
+			ExtensionContainerRootScope rootScope)
 		{
 			scopeCache = new ScopeCache();
-			if(parent == null)
-			{
-				this.parent = ExtensionContainerRootScope.RootScope;
-			}
-			else
-			{
-				this.parent = parent;
-			}
+			this.parent = parent ?? rootScope;
+			this.rootScope = rootScope;
 		}
 
-		public static ExtensionContainerScope BeginScope(ExtensionContainerScope parent)
+		public ExtensionContainerRootScope RootScope
+			=> this as ExtensionContainerRootScope ?? rootScope;
+
+		public static ExtensionContainerScope BeginScope(ExtensionContainerScope parent, ExtensionContainerRootScope rootScope)
 		{
-			var scope = new ExtensionContainerScope(parent);
+			if (rootScope == null)
+				throw new ArgumentNullException(nameof(rootScope));
+
+			var scope = new ExtensionContainerScope(parent, rootScope);
 			current.Value = scope;
 			return scope;
 		}
 
-
 		public void Dispose()
 		{
 			var disposableCache = scopeCache as IDisposable;
@@ -65,7 +67,6 @@ public Burden GetCachedInstance(ComponentModel model, ScopedInstanceActivationCa
 		{
 			lock (scopeCache)
 			{
-
 				// Add transient's burden to scope so it gets released
 				if (model.Configuration.Attributes.Get(TransientMarker) == bool.TrueString)
 				{
@@ -102,4 +103,4 @@ public void Dispose()
 			}
 		}
 	}
-}
+}

src/Castle.Windsor.Extensions.DependencyInjection/WindsorScopeFactory.cs

@@ -16,29 +16,37 @@
 namespace Castle.Windsor.Extensions.DependencyInjection
 {
 	using System;
-	
+
 	using Castle.Windsor;
 	using Castle.Windsor.Extensions.DependencyInjection.Scope;
-	
+
 	using Microsoft.Extensions.DependencyInjection;
 
 	internal class WindsorScopeFactory : IServiceScopeFactory
 	{
 		private readonly IWindsorContainer scopeFactoryContainer;
+		private readonly ExtensionContainerRootScope rootScope;
 
-		public WindsorScopeFactory(IWindsorContainer container)
+		public WindsorScopeFactory(
+			IWindsorContainer container,
+			ExtensionContainerRootScope rootScope)
 		{
 			scopeFactoryContainer = container;
+			this.rootScope = rootScope;
 		}
 
 		public IServiceScope CreateScope()
 		{
-			var scope = ExtensionContainerScope.BeginScope(ExtensionContainerScope.Current);
-
+			var scope =
+				ExtensionContainerScope
+					.BeginScope(
+						ExtensionContainerScope.Current,
+						rootScope);
+
 			//since WindsorServiceProvider is scoped, this gives us new instance
 			var provider = scopeFactoryContainer.Resolve<IServiceProvider>();
 
 			return new ServiceScope(scope, provider);
 		}
 	}
-}
+}

src/Castle.Windsor.Extensions.DependencyInjection/WindsorServiceProviderFactory.cs

@@ -21,14 +21,14 @@ public sealed class WindsorServiceProviderFactory : WindsorServiceProviderFactor
 
 		public WindsorServiceProviderFactory()
 		{
-			CreateRootContainer();
 			CreateRootScope();
+			CreateRootContainer();
 		}
 
 		public WindsorServiceProviderFactory(IWindsorContainer container)
 		{
-			SetRootContainer(container);
 			CreateRootScope();
+			SetRootContainer(container);
 		}
 	}
-}
+}

src/Castle.Windsor.Extensions.DependencyInjection/WindsorServiceProviderFactoryBase.cs

@@ -46,7 +46,7 @@ protected virtual void CreateRootScope()
 		{
 			rootScope = ExtensionContainerRootScope.BeginRootScope();
 		}
-		
+
 		protected virtual void CreateRootContainer()
 		{
 			SetRootContainer(new WindsorContainer());
@@ -82,7 +82,7 @@ protected virtual IWindsorContainer BuildContainer(IServiceCollection serviceCol
 			RegisterContainer(rootContainer);
 			RegisterProviders(rootContainer);
 			RegisterFactories(rootContainer);
-				
+
 			AddSubResolvers();
 
 			RegisterServiceCollection(serviceCollection, windsorContainer);
@@ -111,6 +111,7 @@ protected virtual void RegisterFactories(IWindsorContainer container)
 			container.Register(Component
 					.For<IServiceScopeFactory>()
 					.ImplementedBy<WindsorScopeFactory>()
+					.DependsOn(Dependency.OnValue<ExtensionContainerRootScope>(rootScope))
 					.LifestyleSingleton(),
 				Component
 					.For<IServiceProviderFactory<IWindsorContainer>>()
@@ -133,4 +134,4 @@ protected virtual void AddSubResolvers()
 			rootContainer.Kernel.Resolver.AddSubResolver(new LoggerDependencyResolver(rootContainer.Kernel));
 		}
 	}
-}
+}