Use Root scope when current is null (fixes #646)

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

@@ -35,9 +35,9 @@ internal static ExtensionContainerScopeBase BeginScope()
 
  public override void Dispose()
  {
- if (ExtensionContainerScopeCache.current.Value == this)
+ if (ExtensionContainerScopeCache.TryCurrent == this)
  {
- ExtensionContainerScopeCache.current.Value = parent;
+ ExtensionContainerScopeCache.Current = parent;
  }
  base.Dispose();
  }

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

@@ -19,13 +19,15 @@ namespace Castle.Windsor.Extensions.DependencyInjection.Scope
 
  internal static class ExtensionContainerScopeCache
  {
- internal static readonly AsyncLocal<ExtensionContainerScopeBase> current = new AsyncLocal<ExtensionContainerScopeBase>();
+ private static readonly AsyncLocal<ExtensionContainerScopeBase> current = new AsyncLocal<ExtensionContainerScopeBase>();
  /// <summary>Current scope for the thread. Initial scope will be set when calling BeginRootScope from a ExtensionContainerRootScope instance.</summary>
  /// <exception cref="InvalidOperationException">Thrown when there is no scope available.</exception>
  internal static ExtensionContainerScopeBase Current
  {
  get => current.Value ?? throw new InvalidOperationException("No scope available");
  set => current.Value = value;
  }
+
+ internal static ExtensionContainerScopeBase TryCurrent => current.Value;
  }
 }

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

@@ -23,9 +23,9 @@ internal class ForcedScope : IDisposable
  {
  private readonly ExtensionContainerScopeBase scope;
  private readonly ExtensionContainerScopeBase previousScope;
- internal ForcedScope(ExtensionContainerScopeBase scope)
+ internal ForcedScope(ExtensionContainerScopeBase scope, ExtensionContainerRootScope rootScope)
  {
- previousScope = ExtensionContainerScopeCache.Current;
+ previousScope = ExtensionContainerScopeCache.TryCurrent ?? rootScope;
  this.scope = scope;
  ExtensionContainerScopeCache.Current = scope;
  }

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

@@ -30,24 +30,27 @@ internal class WindsorScopedServiceProvider : IServiceProvider, ISupportRequired
  private bool disposing;
 
  private readonly IWindsorContainer container;
+
+ private readonly ExtensionContainerRootScope rootScope;
 
- public WindsorScopedServiceProvider(IWindsorContainer container)
+ public WindsorScopedServiceProvider(IWindsorContainer container, ExtensionContainerRootScope rootScope)
  {
  this.container = container;
- scope = ExtensionContainerScopeCache.Current;
+ this.scope = ExtensionContainerScopeCache.Current;
+ this.rootScope = rootScope;
  }
 
  public object GetService(Type serviceType)
  {
- using(_ = new ForcedScope(scope))
+ using(_ = new ForcedScope(scope, rootScope))
  {
  return ResolveInstanceOrNull(serviceType, true); 
  }
  }
 
  public object GetRequiredService(Type serviceType)
  {
- using(_ = new ForcedScope(scope))
+ using(_ = new ForcedScope(scope, rootScope))
  {
  return ResolveInstanceOrNull(serviceType, false); 
  }

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

@@ -103,6 +103,7 @@ protected virtual void RegisterProviders(IWindsorContainer container)
  container.Register(Component
  .For<IServiceProvider, ISupportRequiredService>()
  .ImplementedBy<WindsorScopedServiceProvider>()
+ .DependsOn(Dependency.OnValue<ExtensionContainerRootScope>(rootScope))
  .LifeStyle.ScopedToNetServiceScope());
  }