<PackageReference Include="Castle.Windsor" Version="6.0.0" />

---

API Differences between 6.0.0 and 3.2.1

146 Additions 225 Removals

Castle.Core

• public sealed class ComponentModel : GraphNode
  • public IDictionary CustomDependencies { get; }
  • public Arguments CustomDependencies { get; }
  • public IDictionary ExtendedProperties { get; }
  • public Arguments ExtendedProperties { get; }
  • public ComponentModel(ComponentName name, ICollection<Type> services, Type implementation, IDictionary extendedProperties)
  • public ComponentModel(ComponentName name, ICollection<Type> services, Type implementation, Arguments extendedProperties)
• public class CustomLifestyleAttribute : LifestyleAttribute
  • public Type LifestyleHandlerType { get; }
• public class LifecycleConcernsCollection
  • public void Remove(ICommissionConcern concern)
  • public void Remove(IDecommissionConcern concern)
• public enum LifestyleType
  • PerWebRequest = 5
• public sealed class PerWebRequestAttribute : LifestyleAttribute

Castle.Core.Internal

• public class ComponentServicesUtil
  • public static void AddService(IList<Type> existingServices, Type newService)
  • public static void AddService(IList<Type> existingServices, HashSet<Type> lookup, Type newService)
• public static class Constants
  • public static object DefaultComponentForServiceFilter { get; }
  • public static string DefaultComponentForServiceFilter { get; }
  • public static object FallbackComponentForServiceFilter { get; }
  • public static string FallbackComponentForServiceFilter { get; }
  • public static object PropertyFilters { get; }
  • public static object ScopeAccessorType { get; }
  • public static object ScopeRootSelector { get; }
  • protected Constants()
  • public static string PropertyFilters { get; }
  • public static string ScopeAccessorType { get; }
  • public static string ScopeRootSelector { get; }
• public static class ReflectionUtil
  • public static readonly Type[] OpenGenericArrayInterfaces
  • public static TAttribute[] GetAttributes<TAttribute>(this MemberInfo item) where TAttribute : Attribute
  • public static TAttribute[] GetAttributes<TAttribute>(this MemberInfo item, bool inherit) where TAttribute : Attribute
  • public static Assembly[] GetLoadedAssemblies()
• public class SimpleThreadSafeCollection<T>
  • public int Count { get; }
  • public SimpleThreadSafeCollection()
  • public void Add(T item)
  • public bool Remove(T item)
  • public T[] ToArray()
• public class SimpleThreadSafeSet<T>
  • public int Count { get; }
  • public SimpleThreadSafeSet()
  • public bool Add(T item)
  • public bool Remove(T item)
  • public T[] ToArray()

Castle.Facilities.Startable

• public interface IStartFlagInternal
  • void Init(StartableEvents events)
• public class StartableFacility : AbstractFacility
  • public class StartableEvents
  • public static bool IsStartable(IHandler handler)
  • public void DeferredStart(StartFlag flag)
• public class StartFlag : IStartFlagInternal
  • protected StartableEvents events
  • protected readonly List<IHandler> waitList
  • public StartFlag()
  • protected void CacheHandler(IHandler handler)
  • protected virtual void Init()
  • public virtual void Signal()
  • protected virtual void Start(IHandler handler)
  • protected void StartAll()

Castle.Facilities.TypedFactory

• public class DefaultTypedFactoryComponentSelector : ITypedFactoryComponentSelector
  • protected virtual Func<IKernelInternal, IReleasePolicy, object> BuildFactoryComponent(MethodInfo method, string componentName, Type componentType, IDictionary additionalArguments)
  • protected virtual IDictionary GetArguments(MethodInfo method, object[] arguments)
  • protected virtual Func<IKernelInternal, IReleasePolicy, object> BuildFactoryComponent(MethodInfo method, string componentName, Type componentType, Arguments additionalArguments)
  • protected virtual Arguments GetArguments(MethodInfo method, object[] arguments)
• public class TypedFactoryComponentResolver
  • protected readonly IDictionary additionalArguments
  • protected readonly Arguments additionalArguments
  • public TypedFactoryComponentResolver(string componentName, Type componentType, IDictionary additionalArguments, bool fallbackToResolveByTypeIfNameNotFound, Type actualSelectorType)
  • public TypedFactoryComponentResolver(string componentName, Type componentType, Arguments additionalArguments, bool fallbackToResolveByTypeIfNameNotFound, Type actualSelectorType)

Castle.Facilities.TypedFactory.Internal

• public class DelegateFactory : ILazyComponentLoader
  • public IRegistration Load(string name, Type service, IDictionary arguments)
  • public IRegistration Load(string name, Type service, Arguments arguments)

Castle.MicroKernel

• public sealed class Arguments : IEnumerable<KeyValuePair<object, object>>, IEnumerable
  • protected IDictionary arguments
  • public ICollection Keys { get; }
  • public ICollection Values { get; }
  • public Arguments(object namedArgumentsAsAnonymousType, IArgumentsComparer[] customComparers)
  • public Arguments(IDictionary values, IArgumentsComparer[] customComparers)
  • public Arguments(object[] typedArguments, IArgumentsComparer[] customComparers)
  • public Arguments(IArgumentsComparer[] customComparers)
  • public Arguments()
  • public Arguments(Arguments arguments)
  • public static Arguments FromNamed(IEnumerable<KeyValuePair<string, object>> arguments)
  • public static Arguments FromProperties(object instance)
  • public static Arguments FromTyped(IEnumerable<KeyValuePair<Type, object>> arguments)
  • public static Arguments FromTyped(IEnumerable<object> arguments)
  • public void Clear()
  • public Arguments Add(IEnumerable<KeyValuePair<object, object>> arguments)
  • public Arguments AddNamed(string key, object value)
  • public Arguments AddNamed(IEnumerable<KeyValuePair<string, object>> arguments)
  • public Arguments AddProperties(object instance)
  • public Arguments AddTyped(Type key, object value)
  • public Arguments AddTyped<TDependencyType>(TDependencyType value)
  • public Arguments AddTyped(IEnumerable<object> arguments)
  • public Arguments AddTyped(object[] arguments)
  • protected virtual Arguments CreateDeepCopy()
  • public IDictionaryEnumerator GetEnumerator()
  • public IEnumerator<KeyValuePair<object, object>> GetEnumerator()
• public class DefaultKernel : MarshalByRefObject, IKernel, IKernelEvents, IDisposable, IKernelInternal
  • public virtual object this[string key] { get; }
  • public virtual object this[Type service] { get; }
  • public virtual void AddComponent(string key, Type classType)
  • public void AddComponent(string key, Type classType, LifestyleType lifestyle)
  • public void AddComponent(string key, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
  • public virtual void AddComponent(string key, Type serviceType, Type classType)
  • public void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle)
  • public void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
  • public void AddComponent<T>()
  • public void AddComponent<T>(LifestyleType lifestyle)
  • public void AddComponent<T>(LifestyleType lifestyle, bool overwriteLifestyle)
  • public void AddComponent<T>(Type serviceType)
  • public void AddComponent<T>(Type serviceType, LifestyleType lifestyle)
  • public void AddComponent<T>(Type serviceType, LifestyleType lifestyle, bool overwriteLifestyle)
  • public void AddComponentInstance(string key, object instance)
  • public void AddComponentInstance(string key, Type serviceType, object instance)
  • public void AddComponentInstance(string key, Type serviceType, Type classType, object instance)
  • public void AddComponentInstance<T>(object instance)
  • public void AddComponentInstance<T>(Type serviceType, object instance)
  • public virtual void AddComponentWithExtendedProperties(string key, Type classType, IDictionary extendedProperties)
  • public virtual void AddComponentWithExtendedProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
  • public virtual IKernel AddFacility(string key, IFacility facility)
  • public IKernel AddFacility<T>(string key) where T : IFacility
  • public IKernel AddFacility<T>(string key, Action<T> onCreate) where T : IFacility
  • protected CreationContext CreateCreationContext(IHandler handler, Type requestedType, IDictionary additionalArguments, CreationContext parent, IReleasePolicy policy)
  • protected CreationContext CreateCreationContext(IHandler handler, Type requestedType, Arguments additionalArguments, CreationContext parent, IReleasePolicy policy)
  • public virtual IHandler[] GetHandlers()
  • public object Resolve(string key, IDictionary arguments)
  • public object Resolve(string key, object argumentsAsAnonymousType)
  • public virtual object Resolve(string key, Type service, IDictionary arguments)
  • public T Resolve<T>(IDictionary arguments)
  • public T Resolve<T>(object argumentsAsAnonymousType)
  • public virtual object Resolve(string key, Type service, Arguments arguments)
  • public T Resolve<T>(Arguments arguments)
  • public T Resolve<T>(string key, IDictionary arguments)
  • public T Resolve<T>(string key, Arguments arguments)
  • public object Resolve(Type service, IDictionary arguments)
  • public object Resolve(Type service, object argumentsAsAnonymousType)
  • public object Resolve(Type service, Arguments arguments)
  • public Array ResolveAll(Type service, IDictionary arguments)
  • public Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • public TService[] ResolveAll<TService>(object argumentsAsAnonymousType)
  • public TService[] ResolveAll<TService>(IDictionary arguments)
  • public Array ResolveAll(Type service, Arguments arguments)
  • public TService[] ResolveAll<TService>(Arguments arguments)
  • protected object ResolveComponent(IHandler handler, Type service, IDictionary additionalArguments, IReleasePolicy policy)
  • protected object ResolveComponent(IHandler handler, Type service, Arguments additionalArguments, IReleasePolicy policy)
• public interface IComponentModelBuilder
  • ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, IDictionary extendedProperties)
  • ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, Arguments extendedProperties)
• public interface IKernel : IKernelEvents, IDisposable
  • object this[string key] { get; }
  • object this[Type service] { get; }
  • void AddComponent(string key, Type classType)
  • void AddComponent(string key, Type classType, LifestyleType lifestyle)
  • void AddComponent(string key, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
  • void AddComponent(string key, Type serviceType, Type classType)
  • void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle)
  • void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
  • void AddComponent<T>()
  • void AddComponent<T>(LifestyleType lifestyle)
  • void AddComponent<T>(LifestyleType lifestyle, bool overwriteLifestyle)
  • void AddComponent<T>(Type serviceType)
  • void AddComponent<T>(Type serviceType, LifestyleType lifestyle)
  • void AddComponent<T>(Type serviceType, LifestyleType lifestyle, bool overwriteLifestyle)
  • void AddComponentInstance<T>(object instance)
  • void AddComponentInstance<T>(Type serviceType, object instance)
  • void AddComponentInstance(string key, object instance)
  • void AddComponentInstance(string key, Type serviceType, object instance)
  • void AddComponentInstance(string key, Type serviceType, Type classType, object instance)
  • void AddComponentWithExtendedProperties(string key, Type classType, IDictionary extendedProperties)
  • void AddComponentWithExtendedProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
  • IKernel AddFacility(string key, IFacility facility)
  • IKernel AddFacility<T>(string key) where T : IFacility
  • IKernel AddFacility<T>(string key, Action<T> onCreate) where T : IFacility
  • IHandler[] GetHandlers()
  • object Resolve(string key, object argumentsAsAnonymousType)
  • object Resolve(string key, IDictionary arguments)
  • object Resolve(Type service, IDictionary arguments)
  • object Resolve(Type service, object argumentsAsAnonymousType)
  • object Resolve(Type service, Arguments arguments)
  • T Resolve<T>(IDictionary arguments)
  • T Resolve<T>(object argumentsAsAnonymousType)
  • T Resolve<T>(Arguments arguments)
  • T Resolve<T>(string key, IDictionary arguments)
  • object Resolve(string key, Type service, IDictionary arguments)
  • T Resolve<T>(string key, Arguments arguments)
  • object Resolve(string key, Type service, Arguments arguments)
  • Array ResolveAll(Type service, IDictionary arguments)
  • Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • Array ResolveAll(Type service, Arguments arguments)
  • TService[] ResolveAll<TService>(IDictionary arguments)
  • TService[] ResolveAll<TService>(object argumentsAsAnonymousType)
  • TService[] ResolveAll<TService>(Arguments arguments)
• public interface IKernelInternal : IKernel, IKernelEvents, IDisposable
  • IHandler LoadHandlerByName(string key, Type service, IDictionary arguments)
  • IHandler LoadHandlerByType(string key, Type service, IDictionary arguments)
  • IHandler LoadHandlerByName(string key, Type service, Arguments arguments)
  • IHandler LoadHandlerByType(string key, Type service, Arguments arguments)
  • object Resolve(Type service, IDictionary arguments, IReleasePolicy policy)
  • object Resolve(string key, Type service, IDictionary arguments, IReleasePolicy policy)
  • Array ResolveAll(Type service, IDictionary arguments, IReleasePolicy policy)
  • object Resolve(Type service, Arguments arguments, IReleasePolicy policy, bool ignoreParentContext = false)
  • object Resolve(string key, Type service, Arguments arguments, IReleasePolicy policy)
  • Array ResolveAll(Type service, Arguments arguments, IReleasePolicy policy)

Castle.MicroKernel.ComponentActivator

• public class WebUserControlComponentActivator : DefaultComponentActivator

Castle.MicroKernel.Context

• public class CreationContext : MarshalByRefObject, ISubDependencyResolver
  • public IDictionary AdditionalArguments { get; }
  • public Arguments AdditionalArguments { get; }
  • public CreationContext(IHandler handler, IReleasePolicy releasePolicy, Type requestedType, IDictionary additionalArguments, ITypeConverter converter, CreationContext parent)
  • public CreationContext(IHandler handler, IReleasePolicy releasePolicy, Type requestedType, Arguments additionalArguments, ITypeConverter converter, CreationContext parent)

Castle.MicroKernel.Handlers

• public class DefaultGenericHandler : AbstractHandler
  • public IHandler ConvertToClosedGenericHandler(Type service, CreationContext openGenericContext)

Castle.MicroKernel.Internal

• public interface ILockHolder : IDisposable
  • bool LockAcquired { get; }
• public interface IUpgradeableLockHolder : ILockHolder, IDisposable
  • ILockHolder Upgrade()
  • ILockHolder Upgrade(bool waitForLock)
• public class LazyEx<T> : Lazy<T>, IDisposable
  • public LazyEx(IKernel kernel, IDictionary arguments)
  • public LazyEx(IKernel kernel, Arguments arguments)
  • public LazyEx(IKernel kernel, string overrideComponentName, IDictionary arguments)
  • public LazyEx(IKernel kernel, string overrideComponentName, Arguments arguments)
• public abstract class Lock
  • protected Lock()
  • public static Lock Create()
  • public abstract ILockHolder ForReading()
  • public abstract ILockHolder ForReading(bool waitForLock)
  • public abstract IUpgradeableLockHolder ForReadingUpgradeable()
  • public abstract IUpgradeableLockHolder ForReadingUpgradeable(bool waitForLock)
  • public abstract ILockHolder ForWriting()
  • public abstract ILockHolder ForWriting(bool waitForLock)
• public class SlimReadWriteLock : Lock
  • public bool IsReadLockHeld { get; }
  • public bool IsUpgradeableReadLockHeld { get; }
  • public bool IsWriteLockHeld { get; }
  • public SlimReadWriteLock()

Castle.MicroKernel.Lifestyle

• public class PerWebRequestLifestyleModule : IHttpModule
• public static class PerWebRequestLifestyleModuleRegistration
• public class WebRequestScopeAccessor : IScopeAccessor, IDisposable

Castle.MicroKernel.Lifestyle.Scoped

• public class CallContextLifetimeScope : ILifetimeScope, IDisposable
  • public CallContextLifetimeScope(IKernel container)
  • public CallContextLifetimeScope(IWindsorContainer container)
  • public CallContextLifetimeScope()

Castle.MicroKernel.ModelBuilder

• public class DefaultComponentModelBuilder : IComponentModelBuilder
  • public ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, IDictionary extendedProperties)
  • public ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, Arguments extendedProperties)

Castle.MicroKernel.ModelBuilder.Descriptors

• public class CustomDependencyDescriptor : IComponentModelDescriptor
  • public CustomDependencyDescriptor(Arguments arguments)
  • public CustomDependencyDescriptor(IDictionary dictionary)

Castle.MicroKernel.Registration

• public static class AllTypes
• public class AllTypesOf
• public class BasedOnDescriptor : IRegistration
  • public BasedOnDescriptor BasedOn<T>()
  • public BasedOnDescriptor BasedOn(Type basedOn)
  • public BasedOnDescriptor LifestylePerWebRequest()
  • public BasedOnDescriptor Where(Predicate<Type> accepted)
• public static class Classes
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication(Assembly rootAssembly)
• public static class ComponentDependencyRegistrationExtensions
• public class ComponentRegistration<TService> : IRegistration
  • public ComponentRegistration<TService> ActAs(object[] actors)
  • public ComponentRegistration<TService> DependsOn(Arguments dependencies)
  • public ComponentRegistration<TService> LifestylePerWebRequest()
  • public ComponentRegistration<TService> Parameters(Parameter[] parameters)
  • public ComponentRegistration<TService> Properties(Predicate<PropertyInfo> filter)
  • public ComponentRegistration<TService> Properties(Predicate<PropertyInfo> filter, bool isRequired)
  • public ComponentRegistration<TService> Properties(Func<ComponentModel, PropertyInfo, bool> filter, bool isRequired)
  • public ComponentRegistration<TService> ServiceOverrides(ServiceOverride[] overrides)
  • public ComponentRegistration<TService> ServiceOverrides(IDictionary overrides)
  • public ComponentRegistration<TService> ServiceOverrides(object anonymous)
  • public ComponentRegistration<TService> UsingFactory<TFactory, TServiceImpl>(Converter<TFactory, TServiceImpl> factory) where TServiceImpl : TService
  • public ComponentRegistration<TService> UsingFactory<TFactory, TServiceImpl>(Func<TFactory, TServiceImpl> factory) where TServiceImpl : TService
  • public ComponentRegistration<TService> UsingFactoryMethod<TImpl>(Converter<IKernel, TImpl> factoryMethod, bool managedExternally = false) where TImpl : TService
  • public ComponentRegistration<TService> UsingFactoryMethod<TImpl>(Func<IKernel, TImpl> factoryMethod, bool managedExternally = false) where TImpl : TService
• public sealed delegate DynamicParametersDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, Arguments arguments, AsyncCallback callback, object object)
  • public virtual void Invoke(IKernel kernel, IDictionary parameters)
  • public virtual void Invoke(IKernel kernel, Arguments arguments)
• public sealed delegate DynamicParametersResolveDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, Arguments arguments, AsyncCallback callback, object object)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, IDictionary parameters)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, Arguments arguments)
• public sealed delegate DynamicParametersWithContextResolveDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, CreationContext creationContext, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, CreationContext creationContext, Arguments arguments, AsyncCallback callback, object object)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, CreationContext creationContext, IDictionary parameters)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, CreationContext creationContext, Arguments arguments)
• public static class Types
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication(Assembly rootAssembly)

Castle.MicroKernel.Registration.Lifestyle

• public class LifestyleGroup<TService> : RegistrationGroup<TService>
  • public ComponentRegistration<TService> PerWebRequest { get; }

Castle.MicroKernel.Resolvers

• public interface ILazyComponentLoader
  • IRegistration Load(string name, Type service, IDictionary arguments)
  • IRegistration Load(string name, Type service, Arguments arguments)
• public class LazyOfTComponentLoader : ILazyComponentLoader
  • public IRegistration Load(string name, Type service, IDictionary arguments)
  • public IRegistration Load(string name, Type service, Arguments arguments)

Castle.MicroKernel.SubSystems.Conversion

• public class TypeNameConverter : AbstractTypeConverter
  • protected virtual bool ShouldSkipAssembly(AssemblyName assemblyName)

Castle.MicroKernel.SubSystems.Naming

• public class DefaultNamingSubSystem : AbstractSubSystem, INamingSubSystem, ISubSystem
  • protected readonly Lock lock
  • protected readonly IDictionary<Type, IHandler[]> handlerListsByTypeCache
  • protected readonly Lock lock

Castle.Windsor

• public interface IWindsorContainer : IDisposable
  • object this[string key] { get; }
  • object this[Type service] { get; }
  • IWindsorContainer AddComponent(string key, Type classType)
  • IWindsorContainer AddComponent(string key, Type serviceType, Type classType)
  • IWindsorContainer AddComponent<T>()
  • IWindsorContainer AddComponent<T>(string key)
  • IWindsorContainer AddComponent<I, T>()
  • IWindsorContainer AddComponent<I, T>(string key)
  • IWindsorContainer AddComponentLifeStyle(string key, Type classType, LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle(string key, Type serviceType, Type classType, LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle<T>(LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle<T>(string key, LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle<I, T>(LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle<I, T>(string key, LifestyleType lifestyle)
  • IWindsorContainer AddComponentProperties<I, T>(IDictionary extendedProperties)
  • IWindsorContainer AddComponentProperties<I, T>(string key, IDictionary extendedProperties)
  • IWindsorContainer AddComponentWithProperties(string key, Type classType, IDictionary extendedProperties)
  • IWindsorContainer AddComponentWithProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
  • IWindsorContainer AddComponentWithProperties<T>(IDictionary extendedProperties)
  • IWindsorContainer AddComponentWithProperties<T>(string key, IDictionary extendedProperties)
  • IWindsorContainer AddFacility(string idInConfiguration, IFacility facility)
  • IWindsorContainer AddFacility<TFacility>(string idInConfiguration) where TFacility : IFacility
  • IWindsorContainer AddFacility<TFacility>(string idInConfiguration, Action<TFacility> configureFacility) where TFacility : IFacility
  • object Resolve(Type service, IDictionary arguments)
  • object Resolve(Type service, object argumentsAsAnonymousType)
  • object Resolve(Type service, Arguments arguments)
  • T Resolve<T>(IDictionary arguments)
  • T Resolve<T>(object argumentsAsAnonymousType)
  • T Resolve<T>(Arguments arguments)
  • T Resolve<T>(string key, IDictionary arguments)
  • T Resolve<T>(string key, object argumentsAsAnonymousType)
  • object Resolve(string key, Type service, IDictionary arguments)
  • object Resolve(string key, Type service, object argumentsAsAnonymousType)
  • object Resolve(string key, IDictionary arguments)
  • object Resolve(string key, object argumentsAsAnonymousType)
  • T Resolve<T>(string key, Arguments arguments)
  • object Resolve(string key, Type service, Arguments arguments)
  • Array ResolveAll(Type service, IDictionary arguments)
  • Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • T[] ResolveAll<T>(IDictionary arguments)
  • T[] ResolveAll<T>(object argumentsAsAnonymousType)
  • Array ResolveAll(Type service, Arguments arguments)
  • T[] ResolveAll<T>(Arguments arguments)
• public class WindsorContainer : MarshalByRefObject, IWindsorContainer, IDisposable
  • public virtual object this[string key] { get; }
  • public virtual object this[Type service] { get; }
  • public virtual IWindsorContainer AddComponent(string key, Type classType)
  • public virtual IWindsorContainer AddComponent(string key, Type serviceType, Type classType)
  • public IWindsorContainer AddComponent<T>()
  • public IWindsorContainer AddComponent<T>(string key)
  • public IWindsorContainer AddComponent<I, T>(string key)
  • public IWindsorContainer AddComponent<I, T>()
  • public IWindsorContainer AddComponentLifeStyle(string key, Type classType, LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle(string key, Type serviceType, Type classType, LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle<T>(LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle<I, T>(LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle<T>(string key, LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle<I, T>(string key, LifestyleType lifestyle)
  • public IWindsorContainer AddComponentProperties<I, T>(IDictionary extendedProperties)
  • public IWindsorContainer AddComponentProperties<I, T>(string key, IDictionary extendedProperties)
  • public virtual IWindsorContainer AddComponentWithProperties(string key, Type classType, IDictionary extendedProperties)
  • public virtual IWindsorContainer AddComponentWithProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
  • public IWindsorContainer AddComponentWithProperties<T>(IDictionary extendedProperties)
  • public IWindsorContainer AddComponentWithProperties<T>(string key, IDictionary extendedProperties)
  • public virtual IWindsorContainer AddFacility(string idInConfiguration, IFacility facility)
  • public IWindsorContainer AddFacility<T>(string idInConfiguration) where T : IFacility
  • public IWindsorContainer AddFacility<T>(string idInConfiguration, Action<T> configureFacility) where T : IFacility
  • public virtual object Resolve(Type service, IDictionary arguments)
  • public virtual object Resolve(Type service, object argumentsAsAnonymousType)
  • public virtual object Resolve(Type service, Arguments arguments)
  • public virtual object Resolve(string key, Type service, IDictionary arguments)
  • public virtual object Resolve(string key, Type service, object argumentsAsAnonymousType)
  • public T Resolve<T>(IDictionary arguments)
  • public T Resolve<T>(object argumentsAsAnonymousType)
  • public virtual T Resolve<T>(string key, IDictionary arguments)
  • public virtual T Resolve<T>(string key, object argumentsAsAnonymousType)
  • public virtual object Resolve(string key, Type service, Arguments arguments)
  • public T Resolve<T>(Arguments arguments)
  • public virtual T Resolve<T>(string key, Arguments arguments)
  • public virtual object Resolve(string key, IDictionary arguments)
  • public virtual object Resolve(string key, object argumentsAsAnonymousType)
  • public Array ResolveAll(Type service, IDictionary arguments)
  • public Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • public T[] ResolveAll<T>(IDictionary arguments)
  • public T[] ResolveAll<T>(object argumentsAsAnonymousType)
  • public Array ResolveAll(Type service, Arguments arguments)
  • public T[] ResolveAll<T>(Arguments arguments)
• public static class WindsorContainerExtensions
  • public static object Resolve(this IWindsorContainer container, Type service, IEnumerable<KeyValuePair<string, object>> arguments)
  • public static object Resolve(this IWindsorContainer container, string key, Type service, IEnumerable<KeyValuePair<string, object>> arguments)
  • public static T Resolve<T>(this IWindsorContainer container, IEnumerable<KeyValuePair<string, object>> arguments)
  • public static T Resolve<T>(this IWindsorContainer container, string key, IEnumerable<KeyValuePair<string, object>> arguments)
  • public static Array ResolveAll(this IWindsorContainer container, Type service, IEnumerable<KeyValuePair<string, object>> arguments)
  • public static T[] ResolveAll<T>(this IWindsorContainer container, IEnumerable<KeyValuePair<string, object>> arguments)

Castle.Windsor.Diagnostics

• public class DuplicatedDependenciesDiagnostic : IDuplicatedDependenciesDiagnostic, IDiagnostic<Tuple<IHandler, DependencyDuplicate[]>[]>
  • public Pair<IHandler, DependencyDuplicate[]>[] Inspect()
  • public Tuple<IHandler, DependencyDuplicate[]>[] Inspect()

Castle.Windsor.Installer

• public class FromAssembly
  • public static IWindsorInstaller InThisApplication(Assembly rootAssembly)
  • public static IWindsorInstaller InThisApplication(Assembly rootAssembly, InstallerFactory installerFactory)