public void RemoveChild(MsLifetimeScope lifetimeScope)
{
lock (_children)
{
_children.Remove(lifetimeScope);
}
}
private object GetServiceInternal(Type serviceType, bool isOptional)
{
using (MsLifetimeScope.Using(_ownMsLifetimeScope))
{
// MS uses GetService<IEnumerable<TDesiredType>>() to get a collection.
// This must be resolved with IWindsorContainer.ResolveAll();
if (serviceType.IsGenericType && serviceType.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
var allObjects = _container.ResolveAll(serviceType.GenericTypeArguments[0]);
Array.Reverse(allObjects);
return(allObjects);
}
if (!isOptional)
{
return(_container.Resolve(serviceType));
}
// A single service was requested.
// Microsoft.Extensions.DependencyInjection is built to handle optional registrations.
// However Castle Windsor throws a ComponentNotFoundException when a type wasn't registered.
// For this reason we have to manually check if the type exists in Windsor.
if (_container.Kernel.HasComponent(serviceType))
{
return(_container.Resolve(serviceType));
}
//Not found
return(null);
}
}
public void AddChild(MsLifetimeScope lifetimeScope)
{
lock (_children)
{
_children.Add(lifetimeScope);
}
}
private object GetServiceInternal(Type serviceType, bool isOptional)
{
using (MsLifetimeScope.Using(_ownMsLifetimeScope))
{
var isAlreadyInResolving = IsInResolving;
if (!isAlreadyInResolving)
{
IsInResolving = true;
}
object instance = null;
try
{
return(instance = ResolveInstanceOrNull(serviceType, isOptional));
}
finally
{
if (!isAlreadyInResolving)
{
if (instance != null)
{
_ownMsLifetimeScope?.AddInstance(instance);
}
IsInResolving = false;
}
}
}
}
/// <summary>
/// Adds all given services from <see cref="Microsoft.Extensions.DependencyInjection"/>
/// to the Castle Windsor container.
/// </summary>
/// <returns>A Castle Windsor service provider.</returns>
public static IServiceProvider CreateServiceProvider(IWindsorContainer container, IServiceCollection services)
{
AddServices(container, services);
using (MsLifetimeScope.Using(container.Resolve <GlobalMsLifetimeScope>()))
{
return(container.Resolve <GlobalScopedWindsorServiceProvider>());
}
}
public static IDisposable Using(MsLifetimeScope newLifetimeScope)
{
var previous = Current;
Current = newLifetimeScope;
return(new DisposeAction(() =>
{
Current = previous;
}));
}
public WindsorServiceScope(IWindsorContainer container, IMsLifetimeScope currentMsLifetimeScope)
{
_parentLifetimeScope = currentMsLifetimeScope;
LifetimeScope = new MsLifetimeScope(container);
_parentLifetimeScope?.AddChild(LifetimeScope);
_msLifetimeScopeDisposable = MsLifetimeScope.Using(LifetimeScope);
ServiceProvider = container.Resolve <IServiceProvider>();
}
public override object Resolve(CreationContext context, IReleasePolicy releasePolicy)
{
if (MsLifetimeScope.Current == null)
{
return(base.Resolve(context, releasePolicy));
}
using (MsLifetimeScope.Using(_globalMsLifetimeScopeProvider.LifetimeScope))
{
return(base.Resolve(context, releasePolicy));
}
}
public WindsorServiceScope(IWindsorContainer container, MsLifetimeScope currentMsLifetimeScope)
{
_parentLifetimeScope = currentMsLifetimeScope;
LifetimeScope = new MsLifetimeScope();
_parentLifetimeScope?.AddChild(LifetimeScope);
using (MsLifetimeScope.Using(LifetimeScope))
{
ServiceProvider = container.Resolve <IServiceProvider>();
}
}
public ScopedWindsorServiceProvider(IWindsorContainer container, MsLifetimeScopeProvider msLifetimeScopeProvider)
{
_container = container;
_ownMsLifetimeScope = msLifetimeScopeProvider.LifetimeScope;
}
public WindsorServiceScopeFactory(IWindsorContainer container, MsLifetimeScopeProvider msLifetimeScopeProvider)
{
_container = container;
_msLifetimeScope = msLifetimeScopeProvider.LifetimeScope;
}
public GlobalMsLifetimeScopeProvider()
{
LifetimeScope = new MsLifetimeScope();
}