<PackageReference Include="castle.windsor" Version="2.1.1" />

---

API Differences between 2.1.1 and 5.1.0-beta001

156 Additions 415 Removals

Castle.Core

• public sealed class BoundToAttribute : LifestyleAttribute
• public class CastleComponentAttribute : LifestyleAttribute
• public sealed class ComponentActivatorAttribute : Attribute
• public class ComponentDependencyModel : DependencyModel
• public sealed class ComponentModel : GraphNode
• public class ComponentName
• public sealed class ComponentProxyBehaviorAttribute : Attribute
• public class ConstructorCandidate : IComparable<ConstructorCandidate>
• public class ConstructorCandidateCollection : IMutableCollection<ConstructorCandidate>, IEnumerable<ConstructorCandidate>, IEnumerable
• public class ConstructorDependencyModel : DependencyModel
• public class CustomLifestyleAttribute : LifestyleAttribute
• public class DependencyModel
• public class DependencyModelCollection : IMutableCollection<DependencyModel>, IEnumerable<DependencyModel>, IEnumerable
• public sealed class DoNotSelectAttribute : Attribute
• public sealed class DoNotWireAttribute : Attribute
• public interface ICommissionConcern
• public interface IDecommissionConcern
• public interface IInitializable
• public class InterceptorAttribute : Attribute
• public class InterceptorReference : IReference<IInterceptor>, IEquatable<InterceptorReference>
• public class InterceptorReferenceCollection : IMutableCollection<InterceptorReference>, IEnumerable<InterceptorReference>, IEnumerable
• public interface IRecyclable
• public interface IStartable
• public class LifecycleConcernsCollection
• public abstract class LifestyleAttribute : Attribute
• public enum LifestyleType
• public class MethodMetaModel
• public class MethodMetaModelCollection : Collection<MethodMetaModel>
• public class ParameterModel
• public class ParameterModelCollection : IEnumerable<ParameterModel>, IEnumerable
• public sealed class PerThreadAttribute : LifestyleAttribute
• public sealed class PooledAttribute : LifestyleAttribute
• public enum PropertiesInspectionBehavior
• public sealed delegate PropertyDependencyFilter : MulticastDelegate
• public class PropertyDependencyModel : DependencyModel
• public enum PropertyFilter
• public class PropertySet
• public sealed delegate PropertySetBuilder : MulticastDelegate
• public class PropertySetCollection : IMutableCollection<PropertySet>, IEnumerable<PropertySet>, IEnumerable
• public class ScopedAttribute : LifestyleAttribute
• public sealed class SingletonAttribute : LifestyleAttribute
• public class StandardPropertyFilters
• public sealed class TransientAttribute : LifestyleAttribute

Castle.Core.Interceptor

• public interface IOnBehalfAware

Castle.Core.Internal

• public static class ComponentModelExtensions
• public class ComponentServicesUtil
• public static class Constants
• public static class ExceptionHelper
• public class GraphNode : IVertex
• public static class HelpfulExceptionsUtil
• public interface IAssemblyProvider
• public interface IMutableCollection<T> : IEnumerable<T>, IEnumerable
• public interface IVertex
• public sealed class LateBoundComponent
• public static class LifestyleExtensions
• public static class Must
• public static class ReflectionUtil
• public class SegmentedList<T>
• public class SimpleSortedSet<T> : ICollection<T>, IEnumerable<T>, IEnumerable
• public class SimpleThreadSafeCollection<T>
• public class SimpleThreadSafeDictionary<TKey, TValue>
• public class SimpleThreadSafeSet<T>
• public static class StringExtensions
• public struct ThreadSafeFlag
• public sealed class ThreadSafeInit
• public abstract class TopologicalSortAlgo
• public class TypeByInheritanceDepthMostSpecificFirstComparer : IComparer<Type>
• public static class TypeUtil

Castle.Facilities.Startable

• public interface IStartFlagInternal
• public class StartableContributor : IContributeComponentModelConstruction
• public class StartableFacility : AbstractFacility
• public static class StartableFacilityRegistrationExtensions
• public class StartConcern : ICommissionConcern
• public class StartFlag : IStartFlagInternal
• public class StopConcern : IDecommissionConcern

Castle.Facilities.TypedFactory

• public class DefaultDelegateComponentSelector : DefaultTypedFactoryComponentSelector
• public class DefaultTypedFactoryComponentSelector : ITypedFactoryComponentSelector
• public class DelegateFactoryActivator : AbstractComponentActivator, IDependencyAwareActivator
• public class FactoryAttribute : Attribute
• public class FactoryEntry
• public interface ITypedFactoryComponentSelector
• public class TypedFactoryCachingInspector : IContributeComponentModelConstruction
• public class TypedFactoryComponentResolver
• public class TypedFactoryConfiguration
• public class TypedFactoryFacility : AbstractFacility
• public static class TypedFactoryRegistrationExtensions

Castle.Facilities.TypedFactory.Internal

• public class DelegateFactory : ILazyComponentLoader
• public class DelegateProxyFactory : IProxyFactoryExtension
• public class DelegateServiceStrategy : IGenericServiceStrategy
• public class Empty
• public class FactoryInterceptor : IInterceptor, IOnBehalfAware
• public enum FactoryMethod
• public class TypedFactoryInterceptor : IInterceptor, IOnBehalfAware, IDisposable

Castle.MicroKernel

• public abstract class AbstractSubSystem : ISubSystem
• public sealed class Arguments : IEnumerable<KeyValuePair<object, object>>, IEnumerable
• public class Burden
• public sealed delegate BurdenReleaseDelegate : MulticastDelegate
• public class CircularDependencyException : ComponentResolutionException
• public sealed delegate ComponentDataDelegate : MulticastDelegate
• public sealed delegate ComponentInstanceDelegate : MulticastDelegate
• public sealed delegate ComponentModelDelegate : MulticastDelegate
• public class ComponentNotFoundException : ComponentResolutionException
• public class ComponentReference<T> : IReference<T>
• public class ComponentRegistrationException : Exception
• public class ComponentResolutionException : Exception
• public class DefaultKernel : IKernel, IKernelEvents, IDisposable, IKernelInternal
• public sealed delegate DependencyDelegate : MulticastDelegate
• public sealed delegate HandlerDelegate : MulticastDelegate
• public sealed delegate HandlersChangedDelegate : MulticastDelegate
• public enum HandlerState
• public sealed delegate HandlerStateDelegate : MulticastDelegate
• public interface IComponentActivator
• public interface IComponentModelBuilder
• public interface IContextLifestyleManager
• public interface IDependencyResolver : ISubDependencyResolver
• public interface IFacility
• public interface IHandler : ISubDependencyResolver
• public interface IHandlerFactory
• public interface IHandlerSelector
• public interface IHandlersFilter
• public interface IKernel : IKernelEvents, IDisposable
• public interface IKernelEvents
• public interface IKernelInternal : IKernel, IKernelEvents, IDisposable
• public interface ILifestyleManager : IDisposable
• public class InstanceReference<T> : IReference<T>
• public interface IProxyFactory
• public interface IProxyFactoryExtension
• public interface IReference<T>
• public interface IReleasePolicy : IDisposable
• public interface ISubDependencyResolver
• public interface ISubSystem
• public class KernelException : Exception
• public sealed delegate ServiceDelegate : MulticastDelegate
• public abstract class SubSystemConstants

Castle.MicroKernel.ComponentActivator

• public abstract class AbstractComponentActivator : IComponentActivator
• public class ComponentActivatorException : ComponentResolutionException
• public class DefaultComponentActivator : AbstractComponentActivator
• public class ExternalInstanceActivator : AbstractComponentActivator, IDependencyAwareActivator
• public class FactoryMethodActivator<T> : DefaultComponentActivator, IDependencyAwareActivator
• public interface IDependencyAwareActivator
• public class NoResolvableConstructorFoundException : ComponentActivatorException

Castle.MicroKernel.Context

• public class CreationContext : ISubDependencyResolver
• public interface IArgumentsComparer

Castle.MicroKernel.Facilities

• public abstract class AbstractFacility : IFacility, IDisposable
• public class FacilityException : Exception

Castle.MicroKernel.Handlers

• public abstract class AbstractHandler : IHandler, ISubDependencyResolver, IExposeDependencyInfo, IDisposable
• public class ComponentLifecycleExtension : IResolveExtension
• public sealed delegate ComponentReleasingDelegate : MulticastDelegate
• public sealed delegate ComponentResolvingDelegate : MulticastDelegate
• public class DefaultGenericHandler : AbstractHandler
• public class DefaultHandler : AbstractHandler
• public class DefaultHandlerFactory : IHandlerFactory
• public class DependencyInspector : IDependencyInspector
• public class ExtendedHandler : DefaultHandler
• public class GenericHandlerTypeMismatchException : HandlerException
• public class HandlerException : Exception
• public static class HandlerExtensionsUtil
• public interface IDependencyInspector
• public interface IExposeDependencyInfo
• public interface IGenericImplementationMatchingStrategy
• public interface IGenericServiceStrategy
• public interface IReleaseExtension
• public interface IResolveExtension
• public class ParentHandlerWrapper : IHandler, ISubDependencyResolver, IDisposable
• public class ReleaseInvocation
• public class ResolveInvocation

Castle.MicroKernel.Internal

• public class LazyEx<T> : Lazy<T>, IDisposable
• public class LazyServiceStrategy : IGenericServiceStrategy

Castle.MicroKernel.LifecycleConcerns

• public class DisposalConcern : IDecommissionConcern
• public class InitializationConcern : ICommissionConcern
• public class LateBoundCommissionConcerns : LateBoundConcerns<ICommissionConcern>, ICommissionConcern
• public abstract class LateBoundConcerns<TConcern>
• public class LateBoundDecommissionConcerns : LateBoundConcerns<IDecommissionConcern>, IDecommissionConcern
• public sealed delegate LifecycleActionDelegate<T> : MulticastDelegate
• public class OnCreatedConcern<TComponent> : ICommissionConcern
• public class OnDestroyConcern<TComponent> : IDecommissionConcern

Castle.MicroKernel.Lifestyle

• public abstract class AbstractLifestyleManager : ILifestyleManager, IDisposable
• public static class LifestyleExtensions
• public class LifetimeScopeAccessor : IScopeAccessor, IDisposable
• public class PoolableLifestyleManager : AbstractLifestyleManager
• public class ScopedLifestyleManager : AbstractLifestyleManager
• public class SingletonLifestyleManager : AbstractLifestyleManager, IContextLifestyleManager
• public class ThreadScopeAccessor : IScopeAccessor, IDisposable
• public class TransientLifestyleManager : AbstractLifestyleManager

Castle.MicroKernel.Lifestyle.Pool

• public class DefaultPool : IPool, IDisposable
• public class DefaultPoolFactory : IPoolFactory
• public interface IPool : IDisposable
• public interface IPoolFactory
• public class PoolException : Exception

Castle.MicroKernel.Lifestyle.Scoped

• public class CallContextLifetimeScope : ILifetimeScope, IDisposable
• public class CreationContextScopeAccessor : IScopeAccessor, IDisposable
• public class DefaultLifetimeScope : ILifetimeScope, IDisposable
• public interface ILifetimeScope : IDisposable
• public interface IScopeAccessor : IDisposable
• public interface IScopeCache
• public class ScopeCache : IScopeCache, IDisposable
• public sealed delegate ScopedInstanceActivationCallback : MulticastDelegate

Castle.MicroKernel.ModelBuilder

• public static class ComponentModelDescriptorUtil
• public class DefaultComponentModelBuilder : IComponentModelBuilder
• public interface IComponentModelDescriptor
• public interface IContributeComponentModelConstruction
• public interface IMetaComponentModelDescriptor

Castle.MicroKernel.ModelBuilder.Descriptors

• public abstract class AbstractOverwriteableDescriptor<TService> : IComponentModelDescriptor
• public abstract class AbstractPropertyDescriptor : IComponentModelDescriptor
• public class AttributeDescriptor<S> : AbstractOverwriteableDescriptor<S>
• public class AttributeKeyDescriptor<S>
• public class ConfigurationDescriptor : IComponentModelDescriptor
• public class CustomDependencyDescriptor : IComponentModelDescriptor
• public class DefaultsDescriptor : IComponentModelDescriptor
• public class DelegatingModelDescriptor : IComponentModelDescriptor
• public class DynamicParametersDescriptor : IComponentModelDescriptor
• public class ExtendedPropertiesDescriptor : IComponentModelDescriptor
• public class InterceptorDescriptor : IComponentModelDescriptor
• public class InterceptorSelectorDescriptor : IComponentModelDescriptor
• public class LifestyleDescriptor<S> : AbstractOverwriteableDescriptor<S>
• public class OnCreateComponentDescriptor<S> : IComponentModelDescriptor, IMetaComponentModelDescriptor
• public class OnDestroyComponentDescriptor<S> : IComponentModelDescriptor, IMetaComponentModelDescriptor
• public class ParametersDescriptor : AbstractPropertyDescriptor
• public class ProxyHookDescriptor : IComponentModelDescriptor
• public class ProxyInterfacesDescriptor : IComponentModelDescriptor
• public class ProxyMixInsDescriptor : IComponentModelDescriptor
• public class ReferenceDependencyDescriptor : IComponentModelDescriptor
• public class ServiceOverrideDescriptor : AbstractPropertyDescriptor
• public class ServicesDescriptor : IComponentModelDescriptor

Castle.MicroKernel.ModelBuilder.Inspectors

• public class ComponentActivatorInspector : IContributeComponentModelConstruction
• public class ComponentProxyInspector : IContributeComponentModelConstruction
• public class ConfigurationModelInspector : IContributeComponentModelConstruction
• public class ConfigurationParametersInspector : IContributeComponentModelConstruction
• public class ConstructorDependenciesModelInspector : IContributeComponentModelConstruction
• public class GenericInspector : IContributeComponentModelConstruction
• public class InterceptorInspector : IContributeComponentModelConstruction
• public class LifecycleModelInspector : IContributeComponentModelConstruction
• public class LifestyleModelInspector : IContributeComponentModelConstruction
• public abstract class MethodMetaInspector : IContributeComponentModelConstruction
• public class MixinInspector : IContributeComponentModelConstruction
• public class PropertiesDependenciesModelInspector : IContributeComponentModelConstruction

Castle.MicroKernel.Proxy

• public interface IModelInterceptorsSelector
• public class NotSupportedProxyFactory : IProxyFactory
• public abstract class ProxyConstants
• public class ProxyOptions
• public static class ProxyOptionsUtil

Castle.MicroKernel.Registration

• public class AssemblyFilter : IAssemblyProvider
• public class Attrib : Node
• public class BasedOnDescriptor : IRegistration
• public abstract class Child
• public static class Classes
• public class ComplexChild : Node
• public static class Component
• public class ComponentRegistration : ComponentRegistration<object>
• public class ComponentRegistration<TService> : IRegistration
• public class CompoundChild : Node
• public sealed class Dependency
• public sealed delegate DynamicParametersDelegate : MulticastDelegate
• public sealed delegate DynamicParametersResolveDelegate : MulticastDelegate
• public sealed delegate DynamicParametersWithContextResolveDelegate : MulticastDelegate
• public class FromAssemblyDescriptor : FromDescriptor
• public abstract class FromDescriptor : IRegistration
• public class FromTypesDescriptor : FromDescriptor
• public interface IRegistration
• public interface IWindsorInstaller
• public class NamedAttribute
• public class NamedChild : Node
• public abstract class Node
• public class Parameter
• public class ParameterKey
• public class Property
• public class PropertyKey
• public abstract class RegistrationGroup<S>
• public class ServiceDescriptor
• public class ServiceOverride
• public class ServiceOverrideKey
• public class SimpleChild : Node
• public static class Types

Castle.MicroKernel.Registration.Interceptor

• public class InterceptorGroup<S> : RegistrationGroup<S>

Castle.MicroKernel.Registration.Lifestyle

• public class LifestyleGroup<TService> : RegistrationGroup<TService>

Castle.MicroKernel.Registration.Proxy

• public class ItemRegistration<TItem>
• public class MixinRegistration : IEnumerable<IReference<object>>, IEnumerable
• public class ProxyGroup<S> : RegistrationGroup<S>

Castle.MicroKernel.Releasers

• public class LifecycledComponentsReleasePolicy : IReleasePolicy, IDisposable
• public class NoTrackingReleasePolicy : IReleasePolicy, IDisposable

Castle.MicroKernel.Resolvers

• public class DefaultDependencyResolver : IDependencyResolver, ISubDependencyResolver
• public class DependencyResolverException : Exception
• public interface ILazyComponentLoader
• public class LazyOfTComponentLoader : ILazyComponentLoader

Castle.MicroKernel.Resolvers.SpecializedResolvers

• public class ArrayResolver : CollectionResolver
• public class CollectionResolver : ISubDependencyResolver
• public class ListResolver : CollectionResolver

Castle.MicroKernel.SubSystems.Configuration

• public class DefaultConfigurationStore : AbstractSubSystem, IConfigurationStore, ISubSystem
• public interface IConfigurationStore : ISubSystem

Castle.MicroKernel.SubSystems.Conversion

• public abstract class AbstractTypeConverter : ITypeConverter
• public class ArrayConverter : AbstractTypeConverter
• public class AttributeAwareConverter : AbstractTypeConverter
• public class ComponentConverter : AbstractTypeConverter, IKernelDependentConverter
• public class ComponentModelConverter : AbstractTypeConverter
• public class ConverterException : Exception
• public class ConvertibleAttribute : Attribute
• public class DefaultComplexConverter : AbstractTypeConverter
• public class DefaultConversionManager : AbstractSubSystem, IConversionManager, ITypeConverter, ISubSystem, ITypeConverterContext
• public class DictionaryConverter : AbstractTypeConverter
• public class EnumConverter : AbstractTypeConverter
• public class GenericDictionaryConverter : AbstractTypeConverter
• public class GenericListConverter : AbstractTypeConverter
• public interface IConversionManager : ITypeConverter, ISubSystem
• public interface IGenericCollectionConverterHelper
• public interface IKernelDependentConverter
• public interface ITypeConverter
• public interface ITypeConverterContext
• public interface ITypeNameParser
• public class ListConverter : AbstractTypeConverter
• public class PrimitiveConverter : AbstractTypeConverter
• public static class SubSystemExtensions
• public class TimeSpanConverter : AbstractTypeConverter
• public class TypeName
• public class TypeNameConverter : AbstractTypeConverter
• public class TypeNameParser : ITypeNameParser

Castle.MicroKernel.SubSystems.Naming

• public class DefaultNamingSubSystem : AbstractSubSystem, INamingSubSystem, ISubSystem
• public interface INamingSubSystem : ISubSystem

Castle.MicroKernel.SubSystems.Resource

• public class DefaultResourceSubSystem : AbstractSubSystem, IResourceSubSystem, ISubSystem
• public interface IResourceSubSystem : ISubSystem

Castle.MicroKernel.Util

• public abstract class ReferenceExpressionUtil
• public class SimpleMethodEqualityComparer : IEqualityComparer<MethodInfo>
• public class SimpleTypeEqualityComparer : IEqualityComparer<Type>

Castle.Windsor

• public interface IComponentsInstaller
  • void SetUp(IWindsorContainer container, IConfigurationStore store)
  • void SetUp(IWindsorContainer container, IConfigurationStore store)
• public class InitializationException : Exception
  • public InitializationException()
  • public InitializationException(string message)
  • public InitializationException(Exception innerException)
  • public InitializationException(SerializationInfo info, StreamingContext context)
• public interface IWindsorContainer : IServiceProviderEx, IServiceProvider, IDisposable
  • object this[string key] { get; }
  • object this[Type service] { get; }
  • IWindsorContainer AddFacility(IFacility facility)
  • 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 key, IFacility facility)
  • IWindsorContainer AddFacility<T>(string key) where T : IFacility
  • IWindsorContainer AddFacility<T>(string key, Action<T> onCreate) where T : IFacility
  • IWindsorContainer AddFacility<T>(string key, Func<T, object> onCreate) where T : IFacility
  • IWindsorContainer AddFacility<TFacility>(Action<TFacility> onCreate) where TFacility : IFacility
  • IWindsorContainer AddFacility<T>(Action<T> onCreate) where T : IFacility
  • IWindsorContainer AddFacility<T>(Func<T, object> onCreate) where T : IFacility
  • IWindsorContainer Install(IWindsorInstaller[] installers)
  • IWindsorContainer Install(IWindsorInstaller[] installers)
  • object Resolve(string key)
  • object Resolve(string key, IDictionary arguments)
  • object Resolve(string key, object argumentsAsAnonymousType)
  • 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)
  • 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 interface IWindsorInstaller
  • void Install(IWindsorContainer container, IConfigurationStore store)
• public class WindsorContainer : MarshalByRefObject, IWindsorContainer, IServiceProviderEx, IServiceProvider, IDisposable
  • public virtual object this[string key] { get; }
  • public virtual object this[Type service] { get; }
  • public WindsorContainer(IConfigurationStore store)
  • public WindsorContainer(IConfigurationStore store)
  • public IWindsorContainer AddFacility(IFacility facility)
  • 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 key, IFacility facility)
  • public IWindsorContainer AddFacility<T>(string key) where T : IFacility
  • public IWindsorContainer AddFacility<T>(string key, Action<T> onCreate) where T : IFacility
  • public IWindsorContainer AddFacility<T>(string key, Func<T, object> onCreate) where T : IFacility
  • public IWindsorContainer AddFacility<T>(Func<T, object> onCreate) where T : IFacility
  • public IWindsorContainer Install(IWindsorInstaller[] installers)
  • public object GetService(Type serviceType)
  • public T GetService<T>()
  • public IWindsorContainer Install(IWindsorInstaller[] installers)
  • public virtual object Resolve(Type service, Arguments arguments)
  • public virtual object Resolve(string key)
  • public virtual object Resolve(Type service, IDictionary arguments)
  • public virtual object Resolve(Type service, object argumentsAsAnonymousType)
  • public virtual object Resolve(string key, IDictionary arguments)
  • public virtual object Resolve(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, 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 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
• public class WindsorServiceProvider : IServiceProviderEx, IServiceProvider

Castle.Windsor.Adapters.ComponentModel

• public class ContainerAdapter : ContainerWrapper
  • public ContainerAdapter()
  • public ContainerAdapter(IServiceProvider parentProvider)
  • public ContainerAdapter(IWindsorContainer container)
  • public ContainerAdapter(IWindsorContainer container, IServiceProvider parentProvider)
• public class ContainerWrapper : IContainerAdapter, IComponent, IContainer, IDisposable, IServiceContainer, IServiceProvider, IContainerAccessor
  • public virtual ComponentCollection Components { get; }
  • public IWindsorContainer Container { get; }
  • public virtual ISite Site { get; set; }
  • public event EventHandler Disposed
  • public ContainerWrapper(IWindsorContainer container)
  • public ContainerWrapper(IWindsorContainer container, IServiceProvider parentProvider)
  • public virtual void Add(IComponent component)
  • public virtual void Add(IComponent component, string name)
  • public virtual void AddService(Type serviceType, object serviceInstance)
  • public virtual void AddService(Type serviceType, ServiceCreatorCallback callback)
  • public virtual void AddService(Type serviceType, object serviceInstance, bool promote)
  • public virtual void AddService(Type serviceType, ServiceCreatorCallback callback, bool promote)
  • protected virtual IWindsorContainer CreateDefaultWindsorContainer()
  • protected virtual IContainerAdapterSite CreateSite(IComponent component, string name)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public virtual object GetService(Type serviceType)
  • protected virtual void InternalDisposeContainer()
  • public virtual void Remove(IComponent component)
  • public virtual void RemoveService(Type serviceType)
  • public virtual void RemoveService(Type serviceType, bool promote)
• public interface IContainerAdapter : IComponent, IContainer, IDisposable, IServiceContainer, IServiceProvider, IContainerAccessor
• public interface IContainerAdapterSite : ISite, IServiceProvider
  • string EffectiveName { get; }

Castle.Windsor.Configuration

• public interface IConfigurationInterpreter
  • void ProcessResource(IResource resource, IConfigurationStore store, IKernel kernel)
  • void ProcessResource(IResource resource, IConfigurationStore store)

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
  • protected static readonly string BootstrapNodeName
  • protected static readonly string InstallersNodeName
  • protected static readonly string InstallNodeName
  • protected static readonly string IncludeNodeName
  • protected static readonly string PropertiesNodeName
  • protected static void AddChildContainerConfig(string name, IConfiguration childContainer, IConfigurationStore store)
  • protected static void AddComponentConfig(string id, IConfiguration component, IConfigurationStore store)
  • protected static void AddFacilityConfig(string id, IConfiguration facility, IConfigurationStore store)
  • protected static void AddInstallerConfig(IConfiguration installer, IConfigurationStore store)
  • public AbstractInterpreter()
  • protected static void AddBootstrapComponentConfig(string id, IConfiguration component, IConfigurationStore store)
  • protected static void AddChildContainerConfig(string name, IConfiguration childContainer, IConfigurationStore store)
  • protected static void AddComponentConfig(IConfiguration component, IConfigurationStore store)
  • protected static void AddComponentConfig(string id, IConfiguration component, IConfigurationStore store)
  • protected static void AddFacilityConfig(IConfiguration facility, IConfigurationStore store)
  • protected static void AddFacilityConfig(string id, IConfiguration facility, IConfigurationStore store)
  • public abstract void ProcessResource(IResource resource, IConfigurationStore store, IKernel kernel)
  • protected void ProcessInclude(string uri, IConfigurationStore store)
  • public abstract void ProcessResource(IResource resource, IConfigurationStore store)
• public class ConfigurationProcessingException : Exception
• public class XmlInterpreter : AbstractInterpreter
  • public IKernel Kernel { get; set; }
  • public XmlInterpreter()
  • protected static void Deserialize(XmlNode section, IConfigurationStore store, IConversionManager converter)
  • protected static void Deserialize(XmlNode section, IConfigurationStore store)

Castle.Windsor.Configuration.Interpreters.XmlProcessor

• public class ConfigurationProcessingException : Exception
  • public ConfigurationProcessingException(string message)
  • public ConfigurationProcessingException(string message, Exception innerException)
  • public ConfigurationProcessingException(SerializationInfo info, StreamingContext context)
• public class XmlProcessorException : Exception
  • public XmlProcessorException(SerializationInfo info, StreamingContext context)

Castle.Windsor.Configuration.Interpreters.XmlProcessor.ElementProcessors

• public class UsingElementProcessor : AbstractXmlNodeProcessor

Castle.Windsor.Diagnostics

• public class AllComponentsDiagnostic : IAllComponentsDiagnostic, IDiagnostic<IHandler[]>
• public class AllServicesDiagnostic : IAllServicesDiagnostic, IDiagnostic<ILookup<Type, IHandler>>
• public class ComponentDebuggerExtension : IComponentDebuggerExtension
• public class DefaultDiagnosticsSubSystem : AbstractSubSystem, IDiagnosticsHost, IContainerDebuggerExtensionHost, IEnumerable<IContainerDebuggerExtension>, IEnumerable
• public class DependencyDuplicate
• public enum DependencyDuplicationReason
• public class DuplicatedDependenciesDiagnostic : IDuplicatedDependenciesDiagnostic, IDiagnostic<Pair<IHandler, DependencyDuplicate[]>[]>
• public interface IAllComponentsDiagnostic : IDiagnostic<IHandler[]>
• public interface IAllServicesDiagnostic : IDiagnostic<ILookup<Type, IHandler>>
• public interface IComponentDebuggerExtension
• public interface IContainerDebuggerExtension
• public interface IContainerDebuggerExtensionHost : IEnumerable<IContainerDebuggerExtension>, IEnumerable
• public interface IDiagnostic<T>
• public interface IDiagnosticsHost
• public interface IDiagnosticsInspector<TData, TContext>
• public interface IDiagnosticsSource<TResult>
• public interface IDuplicatedDependenciesDiagnostic : IDiagnostic<Pair<IHandler, DependencyDuplicate[]>[]>
• public interface IExposeDiagnostics<TData>
• public interface IPerformanceMetricsFactory
• public interface IPotentialLifestyleMismatchesDiagnostic : IDiagnostic<IHandler[][]>
• public interface IPotentiallyMisconfiguredComponentsDiagnostic : IDiagnostic<IHandler[]>
• public interface ITrackedComponentsDiagnostic : IDiagnostic<ILookup<IHandler, object>>
• public interface ITrackedComponentsPerformanceCounter
• public interface IUsingContainerAsServiceLocatorDiagnostic : IDiagnostic<IHandler[]>
• public class NullPerformanceCounter : ITrackedComponentsPerformanceCounter
• public class PotentialLifestyleMismatchesDiagnostic : IPotentialLifestyleMismatchesDiagnostic, IDiagnostic<IHandler[][]>
• public class PotentiallyMisconfiguredComponentsDiagnostic : IPotentiallyMisconfiguredComponentsDiagnostic, IDiagnostic<IHandler[]>
• public class TrackedComponentsDiagnostic : ITrackedComponentsDiagnostic, IDiagnostic<ILookup<IHandler, object>>
• public class TrackedInstancesEventArgs : EventArgs
• public class UsingContainerAsServiceLocatorDiagnostic : IUsingContainerAsServiceLocatorDiagnostic, IDiagnostic<IHandler[]>

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.Diagnostics.Inspectors

• public interface ITrackedObjectsInspector : IDiagnosticsSource<IEnumerable<KeyValuePair<IHandler, object[]>>>
• public class TrackedObjects

Castle.Windsor.Installer

• public class AssemblyInstaller : IWindsorInstaller
• public class CompositeInstaller : IWindsorInstaller
• public static class Configuration
  • public static ConfigurationInstaller FromAppConfig()
• public class DefaultComponentInstaller : IComponentsInstaller
  • public void SetUp(IWindsorContainer container, IConfigurationStore store)
  • protected virtual void SetUpComponents(IConfiguration[] configurations, IWindsorContainer container, IConversionManager converter)
  • protected virtual void SetUpFacilities(IConfiguration[] configurations, IWindsorContainer container, IConversionManager converter)
  • protected virtual void SetUpInstallers(IConfiguration[] installers, IWindsorContainer container, IConversionManager converter)
  • public void SetUp(IWindsorContainer container, IConfigurationStore store)
  • protected virtual void SetUpComponents(IConfiguration[] configurations, IWindsorContainer container)
  • protected virtual void SetUpFacilities(IConfiguration[] configurations, IWindsorContainer container)
• public class FromAssembly
• public class InstallerFactory

Castle.Windsor.Proxy

• public abstract class AbstractProxyFactory : IProxyFactory
  • public abstract object Create(IKernel kernel, object instance, ComponentModel model, CreationContext context, object[] constructorArguments)
  • public abstract object Create(IProxyFactoryExtension customFactory, IKernel kernel, ComponentModel model, CreationContext context, object[] constructorArguments)
  • public abstract object Create(IKernel kernel, object instance, ComponentModel model, CreationContext context, object[] constructorArguments)
  • protected IInterceptor[] ObtainInterceptors(IKernel kernel, ComponentModel model, CreationContext context)
  • protected IInterceptor[] ObtainInterceptors(IKernel kernel, ComponentModel model, CreationContext context)
• public class DefaultProxyFactory : AbstractProxyFactory, IDeserializationCallback
  • public DefaultProxyFactory(bool disableSignedModule)
  • public DefaultProxyFactory(ProxyGenerator generator)
  • protected static ProxyGenerationOptions CreateProxyGenerationOptionsFrom(ProxyOptions proxyOptions, IKernel kernel, CreationContext context, ComponentModel model)
  • protected static ProxyGenerationOptions CreateProxyGenerationOptionsFrom(ProxyOptions proxyOptions)
  • protected Type[] CollectInterfaces(Type[] interfaces, ComponentModel model)