WindsorContainer
Implementation of IWindsorContainer
which delegates to IKernel implementation.
using Castle.Core;
using Castle.MicroKernel;
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.MicroKernel.SubSystems.Resource;
using Castle.Windsor.Configuration;
using Castle.Windsor.Configuration.Interpreters;
using Castle.Windsor.Diagnostics;
using Castle.Windsor.Installer;
using Castle.Windsor.Proxy;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Text;
using System.Threading;
namespace Castle.Windsor
{
[Serializable]
[DebuggerDisplay("{name,nq}")]
[DebuggerTypeProxy(typeof(KernelDebuggerProxy))]
public class WindsorContainer : MarshalByRefObject, IWindsorContainer, IDisposable
{
private const string CastleUnicode = "🏰";
private static int instanceCount;
private readonly IKernel kernel;
private readonly string name;
private readonly IComponentsInstaller installer;
private IWindsorContainer parent;
private readonly Dictionary<string, IWindsorContainer> childContainers = new Dictionary<string, IWindsorContainer>(StringComparer.OrdinalIgnoreCase);
private readonly object childContainersLocker = new object();
public IComponentsInstaller Installer => installer;
public virtual IKernel Kernel => kernel;
public string Name => name;
public virtual IWindsorContainer Parent {
get {
return parent;
}
set {
if (value == null) {
if (parent != null) {
parent.RemoveChildContainer(this);
parent = null;
}
} else if (value != parent) {
parent = value;
parent.AddChildContainer(this);
}
}
}
[Obsolete("Use Resolve(key, new Arguments()) or Resolve<TService>(key) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual object this[string key] {
get {
return Resolve<object>(key);
}
}
[Obsolete("Use Resolve(service) or generic version instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual object this[Type service] {
get {
return Resolve(service);
}
}
public WindsorContainer()
: this(new DefaultKernel(), new DefaultComponentInstaller())
{
}
public WindsorContainer(IConfigurationStore store)
: this()
{
kernel.ConfigurationStore = store;
RunInstaller();
}
public WindsorContainer(IConfigurationInterpreter interpreter)
: this()
{
if (interpreter == null)
throw new ArgumentNullException("interpreter");
interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);
RunInstaller();
}
public WindsorContainer(IConfigurationInterpreter interpreter, IEnvironmentInfo environmentInfo)
: this()
{
if (interpreter == null)
throw new ArgumentNullException("interpreter");
if (environmentInfo == null)
throw new ArgumentNullException("environmentInfo");
interpreter.EnvironmentName = environmentInfo.GetEnvironmentName();
interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);
RunInstaller();
}
public WindsorContainer(string configurationUri)
: this()
{
if (configurationUri == null)
throw new ArgumentNullException("configurationUri");
XmlInterpreter interpreter = GetInterpreter(configurationUri);
interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);
RunInstaller();
}
public WindsorContainer(IKernel kernel, IComponentsInstaller installer)
: this(MakeUniqueName(), kernel, installer)
{
}
public WindsorContainer(string name, IKernel kernel, IComponentsInstaller installer)
{
if (name == null)
throw new ArgumentNullException("name");
if (kernel == null)
throw new ArgumentNullException("kernel");
if (installer == null)
throw new ArgumentNullException("installer");
this.name = name;
this.kernel = kernel;
this.kernel.ProxyFactory = new DefaultProxyFactory();
this.installer = installer;
}
public WindsorContainer(IProxyFactory proxyFactory)
{
if (proxyFactory == null)
throw new ArgumentNullException("proxyFactory");
kernel = new DefaultKernel(proxyFactory);
installer = new DefaultComponentInstaller();
}
public WindsorContainer(IWindsorContainer parent, IConfigurationInterpreter interpreter)
: this()
{
if (parent == null)
throw new ArgumentNullException("parent");
if (interpreter == null)
throw new ArgumentNullException("interpreter");
parent.AddChildContainer(this);
interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);
RunInstaller();
}
public WindsorContainer(string name, IWindsorContainer parent, IConfigurationInterpreter interpreter)
: this()
{
if (name == null)
throw new ArgumentNullException("name");
if (parent == null)
throw new ArgumentNullException("parent");
if (interpreter == null)
throw new ArgumentNullException("interpreter");
this.name = name;
parent.AddChildContainer(this);
interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore, kernel);
RunInstaller();
}
protected virtual void RunInstaller()
{
if (installer != null)
installer.SetUp(this, kernel.ConfigurationStore);
}
private void Install(IWindsorInstaller[] installers, DefaultComponentInstaller scope)
{
using (PartialConfigurationStore store = new PartialConfigurationStore((IKernelInternal)kernel)) {
for (int i = 0; i < installers.Length; i++) {
installers[i].Install(this, store);
}
scope.SetUp(this, store);
}
}
public virtual void Dispose()
{
Parent = null;
childContainers.Clear();
kernel.Dispose();
}
public virtual void AddChildContainer(IWindsorContainer childContainer)
{
if (childContainer == null)
throw new ArgumentNullException("childContainer");
if (!childContainers.ContainsKey(childContainer.Name)) {
lock (childContainersLocker) {
if (!childContainers.ContainsKey(childContainer.Name)) {
kernel.AddChildKernel(childContainer.Kernel);
childContainers.Add(childContainer.Name, childContainer);
childContainer.Parent = this;
}
}
}
}
public IWindsorContainer AddFacility(IFacility facility)
{
kernel.AddFacility(facility);
return this;
}
public IWindsorContainer AddFacility<T>() where T : IFacility, new
{
kernel.AddFacility<T>();
return this;
}
public IWindsorContainer AddFacility<T>(Action<T> onCreate) where T : IFacility, new
{
kernel.AddFacility(onCreate);
return this;
}
public IWindsorContainer GetChildContainer(string name)
{
lock (childContainersLocker) {
childContainers.TryGetValue(name, out IWindsorContainer value);
return value;
}
}
public IWindsorContainer Install(params IWindsorInstaller[] installers)
{
if (installers == null)
throw new ArgumentNullException("installers");
if (installers.Length == 0)
return this;
DefaultComponentInstaller scope = new DefaultComponentInstaller();
IKernelInternal kernelInternal = kernel as IKernelInternal;
if (kernelInternal == null)
Install(installers, scope);
else {
IDisposable disposable = kernelInternal.OptimizeDependencyResolution();
Install(installers, scope);
disposable?.Dispose();
}
return this;
}
public IWindsorContainer Register(params IRegistration[] registrations)
{
Kernel.Register(registrations);
return this;
}
public virtual void Release(object instance)
{
kernel.ReleaseComponent(instance);
}
public virtual void RemoveChildContainer(IWindsorContainer childContainer)
{
if (childContainer == null)
throw new ArgumentNullException("childContainer");
if (childContainers.ContainsKey(childContainer.Name)) {
lock (childContainersLocker) {
if (childContainers.ContainsKey(childContainer.Name)) {
kernel.RemoveChildKernel(childContainer.Kernel);
childContainers.Remove(childContainer.Name);
childContainer.Parent = null;
}
}
}
}
public virtual object Resolve(Type service, IDictionary arguments)
{
return kernel.Resolve(service, arguments);
}
public virtual object Resolve(Type service, object argumentsAsAnonymousType)
{
return Resolve(service, (IDictionary)new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
}
public virtual object Resolve(Type service)
{
return kernel.Resolve(service, null);
}
public virtual object Resolve(string key, Type service)
{
return kernel.Resolve(key, service, null);
}
public virtual object Resolve(string key, Type service, IDictionary arguments)
{
return kernel.Resolve(key, service, arguments);
}
public virtual object Resolve(string key, Type service, object argumentsAsAnonymousType)
{
return kernel.Resolve(key, service, (IDictionary)new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
}
public T Resolve<T>(IDictionary arguments)
{
return (T)kernel.Resolve(typeof(T), arguments);
}
public T Resolve<T>(object argumentsAsAnonymousType)
{
return (T)kernel.Resolve(typeof(T), (IDictionary)new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
}
public virtual T Resolve<T>(string key, IDictionary arguments)
{
return (T)kernel.Resolve(key, typeof(T), arguments);
}
public virtual T Resolve<T>(string key, object argumentsAsAnonymousType)
{
return (T)kernel.Resolve(key, typeof(T), (IDictionary)new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
}
public T Resolve<T>()
{
return (T)kernel.Resolve(typeof(T), null);
}
public virtual T Resolve<T>(string key)
{
return (T)kernel.Resolve(key, typeof(T), null);
}
public T[] ResolveAll<T>()
{
return (T[])ResolveAll(typeof(T));
}
public Array ResolveAll(Type service)
{
return kernel.ResolveAll(service);
}
public Array ResolveAll(Type service, IDictionary arguments)
{
return kernel.ResolveAll(service, arguments);
}
public Array ResolveAll(Type service, object argumentsAsAnonymousType)
{
return ResolveAll(service, (IDictionary)new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
}
public T[] ResolveAll<T>(IDictionary arguments)
{
return (T[])ResolveAll(typeof(T), arguments);
}
public T[] ResolveAll<T>(object argumentsAsAnonymousType)
{
return ResolveAll<T>((IDictionary)new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
}
private XmlInterpreter GetInterpreter(string configurationUri)
{
try {
return new XmlInterpreter(((IResourceSubSystem)Kernel.GetSubSystem(SubSystemConstants.ResourceKey)).CreateResource(configurationUri));
} catch (Exception) {
return new XmlInterpreter(configurationUri);
}
}
private static string MakeUniqueName()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(AppDomain.CurrentDomain.FriendlyName);
stringBuilder.Append(" ");
stringBuilder.Append("🏰");
stringBuilder.Append(" ");
stringBuilder.Append(Interlocked.Increment(ref instanceCount));
return stringBuilder.ToString();
}
[Obsolete("Use Register(Component.For(classType).Named(key)) or generic version instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual IWindsorContainer AddComponent(string key, Type classType)
{
kernel.AddComponent(key, classType);
return this;
}
[Obsolete("Use Register(Component.For(serviceType).ImplementedBy(classType).Named(key)) or generic version instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual IWindsorContainer AddComponent(string key, Type serviceType, Type classType)
{
kernel.AddComponent(key, serviceType, classType);
return this;
}
[Obsolete("Use Register(Component.For<T>()) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponent<T>()
{
Type typeFromHandle = typeof(T);
AddComponent(ComponentName.DefaultNameFor(typeFromHandle), typeFromHandle);
return this;
}
[Obsolete("Use Register(Component.For<T>().Named(key)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponent<T>(string key)
{
AddComponent(key, typeof(T));
return this;
}
[Obsolete("Use Register(Component.For<I>().ImplementedBy<T>().Named(key)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponent<I, T>(string key) where T : class
{
AddComponent(key, typeof(I), typeof(T));
return this;
}
[Obsolete("Use Register(Component.For<I>().ImplementedBy<T>()) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponent<I, T>() where T : class
{
Type typeFromHandle = typeof(T);
AddComponent(ComponentName.DefaultNameFor(typeFromHandle), typeof(I), typeFromHandle);
return this;
}
[Obsolete("Use Register(Component.For(classType).Named(key).Lifestyle.Is(lifestyle)) or generic version instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentLifeStyle(string key, Type classType, LifestyleType lifestyle)
{
kernel.AddComponent(key, classType, lifestyle, true);
return this;
}
[Obsolete("Use Register(Component.For(serviceType).ImplementedBy(classType).Named(key).Lifestyle.Is(lifestyle)) or generic version instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentLifeStyle(string key, Type serviceType, Type classType, LifestyleType lifestyle)
{
kernel.AddComponent(key, serviceType, classType, lifestyle, true);
return this;
}
[Obsolete("Use Register(Component.For<T>().Lifestyle.Is(lifestyle)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentLifeStyle<T>(LifestyleType lifestyle)
{
Type typeFromHandle = typeof(T);
AddComponentLifeStyle(ComponentName.DefaultNameFor(typeFromHandle), typeFromHandle, lifestyle);
return this;
}
[Obsolete("Use Register(Component.For<I>().ImplementedBy<T>().Lifestyle.Is(lifestyle)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentLifeStyle<I, T>(LifestyleType lifestyle) where T : class
{
Type typeFromHandle = typeof(T);
AddComponentLifeStyle(ComponentName.DefaultNameFor(typeFromHandle), typeof(I), typeFromHandle, lifestyle);
return this;
}
[Obsolete("Use Register(Component.For<T>().Named(key).Lifestyle.Is(lifestyle)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentLifeStyle<T>(string key, LifestyleType lifestyle)
{
AddComponentLifeStyle(key, typeof(T), lifestyle);
return this;
}
[Obsolete("Use Register(Component.For<I>().ImplementedBy<T>().Named(key).Lifestyle.Is(lifestyle)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentLifeStyle<I, T>(string key, LifestyleType lifestyle) where T : class
{
AddComponentLifeStyle(key, typeof(I), typeof(T), lifestyle);
return this;
}
[Obsolete("Use Register(Component.For<I>().ImplementedBy<T>().ExtendedProperties(extendedProperties)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentProperties<I, T>(IDictionary extendedProperties) where T : class
{
Type typeFromHandle = typeof(T);
AddComponentWithProperties(ComponentName.DefaultNameFor(typeFromHandle), typeof(I), typeFromHandle, extendedProperties);
return this;
}
[Obsolete("Use Register(Component.For<I>().ImplementedBy<T>().Named(key).ExtendedProperties(extendedProperties)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentProperties<I, T>(string key, IDictionary extendedProperties) where T : class
{
AddComponentWithProperties(key, typeof(I), typeof(T), extendedProperties);
return this;
}
[Obsolete("Use Register(Component.For(classType).Named(key).ExtendedProperties(extendedProperties)) or generic version instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual IWindsorContainer AddComponentWithProperties(string key, Type classType, IDictionary extendedProperties)
{
kernel.AddComponentWithExtendedProperties(key, classType, extendedProperties);
return this;
}
[Obsolete("Use Register(Component.For(serviceType).ImplementedBy(classType).Named(key).ExtendedProperties(extendedProperties)) or generic version instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual IWindsorContainer AddComponentWithProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
{
kernel.AddComponentWithExtendedProperties(key, serviceType, classType, extendedProperties);
return this;
}
[Obsolete("Use Register(Component.For<T>().ExtendedProperties(extendedProperties)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentWithProperties<T>(IDictionary extendedProperties)
{
Type typeFromHandle = typeof(T);
AddComponentWithProperties(ComponentName.DefaultNameFor(typeFromHandle), typeFromHandle, extendedProperties);
return this;
}
[Obsolete("Use Register(Component.For<T>().Named(key).ExtendedProperties(extendedProperties)) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddComponentWithProperties<T>(string key, IDictionary extendedProperties)
{
AddComponentWithProperties(key, typeof(T), extendedProperties);
return this;
}
[Obsolete("Use AddFacility(IFacility) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual IWindsorContainer AddFacility(string idInConfiguration, IFacility facility)
{
kernel.AddFacility(idInConfiguration, facility);
return this;
}
[Obsolete("Use AddFacility<TFacility>() instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddFacility<T>(string idInConfiguration) where T : IFacility, new
{
kernel.AddFacility<T>(idInConfiguration);
return this;
}
[Obsolete("Use AddFacility<TFacility>(Action<TFacility>) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public IWindsorContainer AddFacility<T>(string idInConfiguration, Action<T> configureFacility) where T : IFacility, new
{
kernel.AddFacility(idInConfiguration, configureFacility);
return this;
}
[Obsolete("Use Resolve<object>(key, arguments) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual object Resolve(string key, IDictionary arguments)
{
return kernel.Resolve<object>(key, arguments);
}
[Obsolete("Use Resolve<object>(key, argumentsAsAnonymousType) instead.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual object Resolve(string key, object argumentsAsAnonymousType)
{
return Resolve<object>(key, (IDictionary)new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
}
}
}