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

---

API Differences between 3.4.0 and 5.1.0

255 Additions 146 Removals

Castle.Core

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

Castle.Core.Internal

• public abstract class Constants
  • public static string DefaultComponentForServiceFilter { get; }
  • public static object DefaultComponentForServiceFilter { get; }
  • public static string FallbackComponentForServiceFilter { get; }
  • public static object FallbackComponentForServiceFilter { get; }
  • public static string PropertyFilters { get; }
  • public static string ScopeAccessorType { get; }
  • public static string ScopeRootSelector { get; }
  • public static object PropertyFilters { get; }
  • public static object ScopeAccessorType { get; }
  • public static object ScopeRootSelector { get; }
  • protected Constants()
• public static class ReflectionUtil
  • public static Assembly GetAssemblyNamed(string filePath, Predicate<AssemblyName> nameFilter, Predicate<Assembly> assemblyFilter)
  • public static TAttribute[] GetAttributes<TAttribute>(this MemberInfo item, bool inherit) where TAttribute : Attribute
  • public static TAttribute[] GetAttributes<TAttribute>(this MemberInfo item) where TAttribute : Attribute
  • public static Assembly[] GetLoadedAssemblies()

Castle.Facilities.TypedFactory

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

Castle.Facilities.TypedFactory.Internal

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

Castle.MicroKernel

• public class Arguments : IDictionary, ICollection, IEnumerable
  • protected IDictionary arguments
  • 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 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 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)
  • public void Clear()
  • public IEnumerator<KeyValuePair<object, object>> GetEnumerator()
  • public IDictionaryEnumerator GetEnumerator()
• public class DefaultKernel : IKernelInternal, IKernel, IKernelEvents, IDisposable
  • 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, Arguments additionalArguments, CreationContext parent, IReleasePolicy policy)
  • protected CreationContext CreateCreationContext(IHandler handler, Type requestedType, IDictionary 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, Arguments arguments)
  • public T Resolve<T>(Arguments arguments)
  • public virtual object Resolve(string key, Type service, IDictionary arguments)
  • public T Resolve<T>(IDictionary arguments)
  • public T Resolve<T>(object argumentsAsAnonymousType)
  • public T Resolve<T>(string key, Arguments arguments)
  • public T Resolve<T>(string key, IDictionary arguments)
  • public object Resolve(Type service, Arguments arguments)
  • public object Resolve(Type service, IDictionary arguments)
  • public object Resolve(Type service, object argumentsAsAnonymousType)
  • public Array ResolveAll(Type service, Arguments arguments)
  • public TService[] ResolveAll<TService>(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)
  • protected object ResolveComponent(IHandler handler, Type service, Arguments additionalArguments, IReleasePolicy policy)
  • protected object ResolveComponent(IHandler handler, Type service, IDictionary additionalArguments, IReleasePolicy policy)
• public interface IComponentModelBuilder
  • ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, Arguments extendedProperties)
  • ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, IDictionary 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, Arguments arguments)
  • object Resolve(Type service, IDictionary arguments)
  • object Resolve(Type service, object argumentsAsAnonymousType)
  • T Resolve<T>(Arguments arguments)
  • T Resolve<T>(IDictionary arguments)
  • T Resolve<T>(object argumentsAsAnonymousType)
  • T Resolve<T>(string key, Arguments arguments)
  • object Resolve(string key, Type service, Arguments arguments)
  • T Resolve<T>(string key, IDictionary arguments)
  • object Resolve(string key, Type service, IDictionary arguments)
  • Array ResolveAll(Type service, Arguments arguments)
  • Array ResolveAll(Type service, IDictionary arguments)
  • Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • TService[] ResolveAll<TService>(Arguments arguments)
  • TService[] ResolveAll<TService>(IDictionary arguments)
  • TService[] ResolveAll<TService>(object argumentsAsAnonymousType)
• public interface IKernelInternal : IKernel, IKernelEvents, IDisposable
  • IHandler LoadHandlerByName(string key, Type service, Arguments arguments)
  • IHandler LoadHandlerByType(string key, Type service, Arguments arguments)
  • IHandler LoadHandlerByName(string key, Type service, IDictionary arguments)
  • IHandler LoadHandlerByType(string key, Type service, IDictionary arguments)
  • 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)
  • 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)

Castle.MicroKernel.Context

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

Castle.MicroKernel.Handlers

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

Castle.MicroKernel.Internal

• public class LazyEx<T> : Lazy<T>, IDisposable
  • public LazyEx(IKernel kernel, Arguments arguments)
  • public LazyEx(IKernel kernel, IDictionary arguments)
  • public LazyEx(IKernel kernel, string overrideComponentName, Arguments arguments)
  • public LazyEx(IKernel kernel, string overrideComponentName, IDictionary arguments)

Castle.MicroKernel.LifecycleConcerns

• public class SupportInitializeConcern : ICommissionConcern
  • public static SupportInitializeConcern Instance { get; }
  • protected SupportInitializeConcern()
  • public void Apply(ComponentModel model, object component)

Castle.MicroKernel.Lifestyle.Scoped

• public class CallContextLifetimeScope : ILifetimeScope, IDisposable
• public class ThreadStaticLifetimeScope : ILifetimeScope, IDisposable
  • public ThreadStaticLifetimeScope(IKernel container)
  • public ThreadStaticLifetimeScope(IWindsorContainer container)
  • public static ThreadStaticLifetimeScope ObtainCurrentScope()
  • public void Dispose()
  • public Burden GetCachedInstance(ComponentModel instance, ScopedInstanceActivationCallback createInstance)

Castle.MicroKernel.ModelBuilder

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

Castle.MicroKernel.ModelBuilder.Descriptors

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

Castle.MicroKernel.Registration

• public class AssemblyFilter : IAssemblyProvider
• public static class AllTypes
  • public static FromTypesDescriptor From(IEnumerable<Type> types)
  • public static FromTypesDescriptor From(Type[] types)
  • public static FromAssemblyDescriptor FromAssembly(Assembly assembly)
  • public static FromAssemblyDescriptor FromAssemblyContaining(Type type)
  • public static FromAssemblyDescriptor FromAssemblyContaining<T>()
  • public static FromAssemblyDescriptor FromAssemblyNamed(string assemblyName)
  • public static FromAssemblyDescriptor FromThisAssembly()
  • public static AllTypesOf Of(Type basedOn)
  • public static AllTypesOf Of<T>()
  • public static AllTypesOf Pick()
  • public static FromTypesDescriptor Pick(IEnumerable<Type> types)
• public class AllTypesOf
  • public BasedOnDescriptor From(IEnumerable<Type> types)
  • public BasedOnDescriptor From(Type[] types)
  • public BasedOnDescriptor FromAssembly(Assembly assembly)
  • public BasedOnDescriptor FromAssemblyNamed(string assemblyName)
  • public BasedOnDescriptor Pick(IEnumerable<Type> types)
• public class BasedOnDescriptor : IRegistration
  • public BasedOnDescriptor BasedOn<T>()
  • public BasedOnDescriptor BasedOn(Type basedOn)
  • public BasedOnDescriptor Where(Predicate<Type> accepted)
• public static class Classes
  • public static FromAssemblyDescriptor FromAssemblyInDirectory(AssemblyFilter filter)
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication(Assembly rootAssembly)
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication()
  • public static FromAssemblyDescriptor FromThisAssembly()
• public static class ComponentDependencyRegistrationExtensions
  • public static IDictionary Insert(this IDictionary arguments, string key, object value)
  • public static IDictionary Insert(this IDictionary arguments, Type dependencyType, object value)
  • public static IDictionary InsertAnonymous(this IDictionary arguments, object namedArgumentsAsAnonymousType)
  • public static IDictionary InsertTyped<TDependencyType>(this IDictionary arguments, TDependencyType value)
  • public static IDictionary InsertTypedCollection(this IDictionary arguments, object[] typedArgumentsArray)
• public class ComponentRegistration<TService> : IRegistration
  • public ComponentRegistration<TService> ActAs(object[] actors)
  • public ComponentRegistration<TService> DependsOn(Arguments dependencies)
  • 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> UsingFactory<TFactory, TServiceImpl>(Func<TFactory, TServiceImpl> factory) where TServiceImpl : TService
  • 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> UsingFactoryMethod<TImpl>(Func<IKernel, TImpl> factoryMethod, bool managedExternally = false) where TImpl : TService
  • public ComponentRegistration<TService> UsingFactoryMethod<TImpl>(Converter<IKernel, TImpl> factoryMethod, bool managedExternally = false) where TImpl : TService
• public sealed delegate DynamicParametersDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, Arguments arguments, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual void Invoke(IKernel kernel, Arguments arguments)
  • public virtual void Invoke(IKernel kernel, IDictionary parameters)
• public sealed delegate DynamicParametersResolveDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, Arguments arguments, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, Arguments arguments)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, IDictionary parameters)
• public sealed delegate DynamicParametersWithContextResolveDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, CreationContext creationContext, Arguments arguments, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, CreationContext creationContext, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, CreationContext creationContext, Arguments arguments)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, CreationContext creationContext, IDictionary parameters)
• public static class Types
  • public static FromAssemblyDescriptor FromAssemblyInDirectory(AssemblyFilter filter)
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication(Assembly rootAssembly)
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication()
  • public static FromAssemblyDescriptor FromThisAssembly()

Castle.MicroKernel.Resolvers

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

Castle.MicroKernel.SubSystems.Conversion

• public class NullableConverter : AbstractTypeConverter
  • public NullableConverter(ITypeConverter innerConverter)
• public class TypeDescriptor
  • public TypeDescriptor()
  • public static TypeConverter GetConverter(Type type)
• public class TypeNameConverter : AbstractTypeConverter
  • protected virtual bool ShouldSkipAssembly(AssemblyName assemblyName)

Castle.MicroKernel.SubSystems.Naming

• public class DefaultNamingSubSystem : AbstractSubSystem, INamingSubSystem, ISubSystem
  • protected readonly IDictionary<Type, IHandler[]> handlerListsByTypeCache
  • protected void InvalidateCache()

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, Arguments arguments)
  • object Resolve(Type service, IDictionary arguments)
  • object Resolve(Type service, object argumentsAsAnonymousType)
  • T Resolve<T>(Arguments arguments)
  • T Resolve<T>(IDictionary arguments)
  • T Resolve<T>(object argumentsAsAnonymousType)
  • T Resolve<T>(string key, Arguments arguments)
  • object Resolve(string key, Type service, 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)
  • Array ResolveAll(Type service, Arguments arguments)
  • T[] ResolveAll<T>(Arguments arguments)
  • Array ResolveAll(Type service, IDictionary arguments)
  • Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • T[] ResolveAll<T>(IDictionary arguments)
  • T[] ResolveAll<T>(object argumentsAsAnonymousType)
• public class WindsorContainer : IWindsorContainer, IDisposable
  • public virtual object this[string key] { get; }
  • public virtual object this[Type service] { get; }
  • public WindsorContainer(string configurationUri)
  • 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, Arguments arguments)
  • public virtual object Resolve(Type service, IDictionary arguments)
  • public virtual object Resolve(Type service, 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, 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, IDictionary arguments)
  • public virtual object Resolve(string key, object argumentsAsAnonymousType)
  • public Array ResolveAll(Type service, Arguments arguments)
  • public T[] ResolveAll<T>(Arguments arguments)
  • 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 static class WindsorContainerExtensions

Castle.Windsor.Configuration.Interpreters

• public class XmlInterpreter : AbstractInterpreter

Castle.Windsor.Configuration.Interpreters.XmlProcessor

• public class DefaultXmlProcessorEngine : IXmlProcessorEngine
• public class DefaultXmlProcessorNodeList : IXmlProcessorNodeList
• public interface IXmlNodeProcessor
• public interface IXmlProcessorEngine
• public interface IXmlProcessorNodeList
• public class XmlProcessor
• public class XmlProcessorException : Exception

Castle.Windsor.Configuration.Interpreters.XmlProcessor.ElementProcessors

• public abstract class AbstractStatementElementProcessor : AbstractXmlNodeProcessor
• public abstract class AbstractXmlNodeProcessor : IXmlNodeProcessor
• public class AttributesElementProcessor : AbstractXmlNodeProcessor
• public class ChooseElementProcessor : AbstractStatementElementProcessor
• public class DefaultElementProcessor : AbstractXmlNodeProcessor
• public class DefaultTextNodeProcessor : AbstractXmlNodeProcessor
• public class DefinedProcessingInstructionProcessor : AbstractXmlNodeProcessor
• public class DefineElementProcessor : AbstractXmlNodeProcessor
• public class EvalProcessingInstructionProcessor : AbstractXmlNodeProcessor
• public class IfElementProcessor : AbstractStatementElementProcessor
• public class IfProcessingInstructionProcessor : AbstractXmlNodeProcessor
• public class IncludeElementProcessor : AbstractXmlNodeProcessor
• public class PropertiesElementProcessor : AbstractXmlNodeProcessor
• public class UndefElementProcessor : DefineElementProcessor
• public class UndefProcessingInstructionProcessor : AbstractStatementElementProcessor
• public class UsingElementProcessor : AbstractXmlNodeProcessor

Castle.Windsor.Diagnostics

• public class ComponentDebuggerExtension : IComponentDebuggerExtension
• public class DefaultDiagnosticsSubSystem : AbstractSubSystem, IDiagnosticsHost
  • public void Add(IContainerDebuggerExtension item)
  • public IEnumerator<IContainerDebuggerExtension> GetEnumerator()
  • protected virtual void InitStandardExtensions()
• public interface IComponentDebuggerExtension
• public interface IContainerDebuggerExtension
• public interface IContainerDebuggerExtensionHost : IEnumerable<IContainerDebuggerExtension>, IEnumerable

Castle.Windsor.Diagnostics.DebuggerViews

• public class ComponentDebuggerView
• public class DebuggerViewItem
• public class DebuggerViewItemWithDetails
• public class MasterDetailsDebuggerViewItem

Castle.Windsor.Diagnostics.Extensions

• public abstract class AbstractContainerDebuggerExtension : IContainerDebuggerExtension
• public class AllComponents : AbstractContainerDebuggerExtension
• public class AllServices : AbstractContainerDebuggerExtension
• public class DuplicatedDependenciesDebuggerExtension : AbstractContainerDebuggerExtension
• public class Facilities : IContainerDebuggerExtension
• public class PotentialLifestyleMismatches : AbstractContainerDebuggerExtension
• public class PotentiallyMisconfiguredComponents : AbstractContainerDebuggerExtension
• public class ReleasePolicyTrackedObjects : AbstractContainerDebuggerExtension
• public class UsingContainerAsServiceLocator : AbstractContainerDebuggerExtension

Castle.Windsor.Diagnostics.Helpers

• public class DefaultComponentViewBuilder : IComponentDebuggerExtension
• public static class DescriptionUtil

Castle.Windsor.Installer

• public static class Configuration
• public class FromAssembly
  • public static IWindsorInstaller InDirectory(AssemblyFilter filter)
  • public static IWindsorInstaller InDirectory(AssemblyFilter filter, InstallerFactory installerFactory)
  • public static IWindsorInstaller InThisApplication(Assembly rootAssembly)
  • public static IWindsorInstaller InThisApplication(Assembly rootAssembly, InstallerFactory installerFactory)
  • public static IWindsorInstaller InThisApplication()
  • public static IWindsorInstaller InThisApplication(InstallerFactory installerFactory)
  • public static IWindsorInstaller This()
  • public static IWindsorInstaller This(InstallerFactory installerFactory)

Castle.Windsor.Proxy

• public class DefaultProxyFactory : AbstractProxyFactory
  • public void OnDeserialization(object sender)