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

---

API Differences between 3.4.0 and 5.1.1

284 Additions 95 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 sealed class ComponentProxyBehaviorAttribute : Attribute
  • public bool UseMarshalByRefProxy { get; set; }
• 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 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, ICloneable
  • 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()
  • protected virtual Arguments CreateDeepCopy()
  • public IDictionaryEnumerator GetEnumerator()
• public class CircularDependencyException : ComponentResolutionException
  • protected CircularDependencyException(SerializationInfo info, StreamingContext context)
• public class ComponentNotFoundException : ComponentResolutionException
  • public ComponentNotFoundException(SerializationInfo info, StreamingContext context)
• public class ComponentRegistrationException : Exception
  • public ComponentRegistrationException(SerializationInfo info, StreamingContext context)
• public class ComponentResolutionException : Exception
  • public ComponentResolutionException(SerializationInfo info, StreamingContext context)
• public class DefaultKernel : MarshalByRefObject, IKernelInternal, IKernel, IKernelEvents, IDisposable
  • public virtual object this[string key] { get; }
  • public virtual object this[Type service] { get; }
  • public DefaultKernel(SerializationInfo info, StreamingContext context)
  • 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 void GetObjectData(SerializationInfo info, StreamingContext context)
  • 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)
• public class KernelException : Exception
  • public KernelException(SerializationInfo info, StreamingContext context)

Castle.MicroKernel.ComponentActivator

• public class ComponentActivatorException : ComponentResolutionException
  • public ComponentActivatorException(SerializationInfo info, StreamingContext context)
• public class NoResolvableConstructorFoundException : ComponentActivatorException
  • public NoResolvableConstructorFoundException(SerializationInfo info, StreamingContext context)

Castle.MicroKernel.Context

• public class CreationContext : MarshalByRefObject, 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.Facilities

• public class FacilityException : Exception
  • public FacilityException(SerializationInfo info, StreamingContext context)

Castle.MicroKernel.Handlers

• public class DefaultGenericHandler : AbstractHandler
  • public IHandler ConvertToClosedGenericHandler(Type service, CreationContext openGenericContext)
• public class GenericHandlerTypeMismatchException : HandlerException
  • public GenericHandlerTypeMismatchException(SerializationInfo info, StreamingContext context)
• public class HandlerException : Exception
  • public HandlerException(SerializationInfo info, StreamingContext context)

Castle.MicroKernel.Internal

• public interface ILockHolder : IDisposable
• public interface IUpgradeableLockHolder : ILockHolder, IDisposable
• 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)
• public abstract class Lock
• public class SlimReadWriteLock : Lock

Castle.MicroKernel.LifecycleConcerns

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

Castle.MicroKernel.Lifestyle.Pool

• public class PoolException : Exception
  • public PoolException(SerializationInfo info, StreamingContext context)

Castle.MicroKernel.Lifestyle.Scoped

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

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.Proxy

• public class ProxyOptions
  • public bool UseMarshalByRefAsBaseClass { get; set; }

Castle.MicroKernel.Registration

• 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 FromAssemblyInDirectory(AssemblyFilter filter)
  • 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 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 class Dependency
  • public static Parameter OnAppSettingsValue(string dependencyName, string settingName)
  • public static Parameter OnAppSettingsValue(string name)
• 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 FromAssemblyInThisApplication(Assembly rootAssembly)
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication()
  • public static FromAssemblyDescriptor FromThisAssembly()

Castle.MicroKernel.Resolvers

• public class DependencyResolverException : Exception
  • public DependencyResolverException(SerializationInfo info, StreamingContext context)
• 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 ConverterException : Exception
  • public ConverterException(SerializationInfo info, StreamingContext context)
• 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 readonly Lock lock
  • 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, 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 : 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, 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.AppDomain

• public class CastleSectionHandler : IConfigurationSectionHandler
  • public CastleSectionHandler()
  • public object Create(object parent, object configContext, XmlNode section)

Castle.Windsor.Configuration.Interpreters

• public abstract class AbstractInterpreter : IConfigurationInterpreter
  • public AbstractInterpreter()
• public class ConfigurationProcessingException : Exception
  • public ConfigurationProcessingException(SerializationInfo info, StreamingContext context)
• public class XmlInterpreter : AbstractInterpreter
  • public XmlInterpreter()

Castle.Windsor.Configuration.Interpreters.XmlProcessor

• public class XmlProcessorException : Exception
  • public XmlProcessorException(SerializationInfo info, StreamingContext context)

Castle.Windsor.Diagnostics

• public class PerformanceMetricsFactory : IPerformanceMetricsFactory
  • public bool InitializedSuccessfully { get; }
  • public PerformanceMetricsFactory()
  • public ITrackedComponentsPerformanceCounter CreateInstancesTrackedByReleasePolicyCounter(string name)
• public class TrackedComponentsPerformanceCounterWrapper : ITrackedComponentsPerformanceCounter, IDisposable
  • public TrackedComponentsPerformanceCounterWrapper(PerformanceCounter counter)
  • public void DecrementTrackedInstancesCount()
  • public void Dispose()
  • public void IncrementTrackedInstancesCount()

Castle.Windsor.Installer

• public static class Configuration
  • public static ConfigurationInstaller FromAppConfig()
• public class FromAssembly
  • 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)