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

---

API Differences between 2.0.0 and 5.0.1

1378 Additions 417 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.EventWiring

• public class EventWiringException : FacilityException
  • public EventWiringException(string message)
  • public EventWiringException(string message, Exception innerException)
  • public EventWiringException(SerializationInfo info, StreamingContext context)
• public class EventWiringFacility : AbstractFacility
  • public EventWiringFacility()

Castle.Facilities.FactorySupport

• public class AccessorActivator : DefaultComponentActivator
  • public AccessorActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class FactoryActivator : DefaultComponentActivator
  • public FactoryActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class FactorySupportFacility : AbstractFacility
  • public FactorySupportFacility()
  • public void AddAccessor<TService, TFactory>(string serviceKey, string instanceAccessorMethod)
  • public void AddAccessor<TService, TFactory>(string serviceKey, string instanceAccessorMethod, string factoryId)
  • public void AddFactory<TService, TFactory>(string serviceKey, string factoryCreateMethodName)
  • public void AddFactory<TService, TFactory>(string serviceKey, string factoryCreateMethodName, string factoryId)

Castle.Facilities.Remoting

• public class RemoteActivator : DefaultComponentActivator
  • public RemoteActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class RemoteActivatorThroughConnector : DefaultComponentActivator
  • public RemoteActivatorThroughConnector(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class RemoteActivatorThroughRegistry : DefaultComponentActivator
  • public RemoteActivatorThroughRegistry(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class RemoteClientActivatedActivator : DefaultComponentActivator
  • public RemoteClientActivatedActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class RemoteMarshallerActivator : DefaultComponentActivator
  • public RemoteMarshallerActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class RemotingFacility : AbstractFacility
  • public RemotingFacility()
• public class RemotingInspector : IContributeComponentModelConstruction
  • public RemotingInspector(ITypeConverter converter, bool isServer, bool isClient, string baseUri, RemotingRegistry remoteRegistry, RemotingRegistry localRegistry)
  • public void ProcessModel(IKernel kernel, ComponentModel model)
• public class RemotingRegistry : MarshalByRefObject, IDisposable
  • public RemotingRegistry(IKernel kernel)
  • public void AddComponentEntry(ComponentModel model)
  • public object CreateRemoteInstance(string key)
  • public object CreateRemoteInstance(Type serviceType)
  • public void Dispose()
  • public void Publish(string key)
  • public void Publish(Type serviceType)

Castle.Facilities.Startable

• public class StartableFacility : AbstractFacility
  • public StartableFacility()
• public class StartConcern : ILifecycleConcern
  • public static StartConcern Instance { get; }
  • protected StartConcern()
  • public void Apply(ComponentModel model, object component)
• public class StopConcern : ILifecycleConcern
  • public static StopConcern Instance { get; }
  • protected StopConcern()
  • public void Apply(ComponentModel model, object component)
• 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 Empty
  • public Empty()
• public class FactoryEntry
  • public string CreationMethod { get; }
  • public string DestructionMethod { get; }
  • public Type FactoryInterface { get; }
  • public string Id { get; }
  • public FactoryEntry(string id, Type factoryInterface, string creationMethod, string destructionMethod)
• public class FactoryInterceptor : IInterceptor, IOnBehalfAware
  • public FactoryInterceptor(IKernel kernel)
  • public void Intercept(IInvocation invocation)
  • public void SetInterceptedComponentModel(ComponentModel target)
• public class TypedFactoryFacility : AbstractFacility
  • public TypedFactoryFacility()
  • protected virtual void AddFactories(IConfiguration facilityConfig, ITypeConverter converter)
  • public void AddTypedFactoryEntry(FactoryEntry entry)
• 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 : MarshalByRefObject, ISubSystem
  • protected IKernel Kernel { get; }
  • protected AbstractSubSystem()
  • public virtual void Init(IKernel kernel)
  • public virtual void Terminate()
• public class Burden
  • public bool GraphRequiresDecommission { get; }
  • public bool HasChildren { get; }
  • public ComponentModel Model { get; }
  • public Burden()
  • public void AddChild(Burden child)
  • public void Release(IReleasePolicy policy)
  • public void SetRootInstance(object instance, IHandler handler, bool hasDecomission)
• public sealed delegate ComponentDataDelegate : MulticastDelegate
  • public ComponentDataDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(string key, IHandler handler, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(string key, IHandler handler)
• public sealed delegate ComponentInstanceDelegate : MulticastDelegate
  • public ComponentInstanceDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ComponentModel model, object instance, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(ComponentModel model, object instance)
• public sealed delegate ComponentModelDelegate : MulticastDelegate
  • public ComponentModelDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ComponentModel model, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(ComponentModel model)
• public class ComponentNotFoundException : ApplicationException
  • public ComponentNotFoundException(string name)
  • public ComponentNotFoundException(Type service)
  • public ComponentNotFoundException(SerializationInfo info, StreamingContext context)
• public class ComponentRegistrationException : ApplicationException
  • public ComponentRegistrationException(string message)
  • public ComponentRegistrationException(SerializationInfo info, StreamingContext context)
• public class CreationContext : MarshalByRefObject, ISubDependencyResolver
  • public class ResolutionContext : IDisposable
  • public static CreationContext Empty { get; }
  • public IDictionary AdditionalParameters { get; }
  • public DependencyModelCollection Dependencies { get; }
  • public Type[] GenericArguments { get; }
  • public IHandler Handler { get; }
  • public bool HasAdditionalParameters { get; }
  • public IReleasePolicy ReleasePolicy { get; }
  • public CreationContext(Type typeToExtractGenericArguments, CreationContext parentContext)
  • public CreationContext(IHandler handler, IReleasePolicy releasePolicy, Type typeToExtractGenericArguments, IDictionary additionalArguments, ITypeConverter conversionManager)
  • public virtual bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public ResolutionContext EnterResolutionContext(IHandler handlerBeingResolved)
  • public ResolutionContext EnterResolutionContext(IHandler handlerBeingResolved, bool createBurden)
  • public bool HandlerIsCurrentlyBeingResolved(IHandler handlerToTest)
  • public IDisposable ParentResolutionContext(CreationContext parent)
  • public virtual object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
• public class DefaultKernel : MarshalByRefObject, IKernel, IServiceProviderEx, IServiceProvider, IDisposable, IKernelEvents, IDeserializationCallback
  • public IComponentModelBuilder ComponentModelBuilder { get; set; }
  • public virtual IConfigurationStore ConfigurationStore { get; set; }
  • protected IConversionManager ConversionSubSystem { get; }
  • public GraphNode[] GraphNodes { get; }
  • public IHandlerFactory HandlerFactory { get; }
  • public virtual object this[string key] { get; }
  • public virtual object this[Type service] { get; }
  • protected INamingSubSystem NamingSubSystem { get; }
  • public virtual IKernel Parent { get; set; }
  • public IProxyFactory ProxyFactory { get; set; }
  • public virtual IReleasePolicy ReleasePolicy { get; set; }
  • public IDependencyResolver Resolver { get; }
  • public event EventHandler AddedAsChildKernel
  • public event ComponentInstanceDelegate ComponentCreated
  • public event ComponentInstanceDelegate ComponentDestroyed
  • public event ComponentModelDelegate ComponentModelCreated
  • public event ComponentDataDelegate ComponentRegistered
  • public event ComponentDataDelegate ComponentUnregistered
  • public event DependencyDelegate DependencyResolving
  • public event HandlerDelegate HandlerRegistered
  • public event HandlersChangedDelegate HandlersChanged
  • public event EventHandler RemovedAsChildKernel
  • public DefaultKernel()
  • public DefaultKernel(IDependencyResolver resolver, IProxyFactory proxyFactory)
  • public DefaultKernel(IProxyFactory proxyFactory)
  • public DefaultKernel(SerializationInfo info, StreamingContext context)
  • public virtual void AddChildKernel(IKernel childKernel)
  • 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 parameters)
  • public virtual void AddComponentWithExtendedProperties(string key, Type serviceType, Type classType, IDictionary parameters)
  • public virtual void AddCustomComponent(ComponentModel model)
  • 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
  • public IKernel AddFacility<T>(string key, Func<T, object> onCreate) where T : IFacility
  • public IKernel AddFacility<T>() where T : IFacility
  • public IKernel AddFacility<T>(Action<T> onCreate) where T : IFacility
  • public IKernel AddFacility<T>(Func<T, object> onCreate) where T : IFacility
  • public void AddHandlerSelector(IHandlerSelector selector)
  • public virtual void AddSubSystem(string key, ISubSystem subsystem)
  • public virtual IComponentActivator CreateComponentActivator(ComponentModel model)
  • protected CreationContext CreateCreationContext(IHandler handler, Type typeToExtractGenericArguments, IDictionary additionalArguments)
  • public virtual void Dispose()
  • protected void DisposeHandler(IHandler handler)
  • public virtual IHandler[] GetAssignableHandlers(Type service)
  • public virtual IFacility[] GetFacilities()
  • public virtual IHandler GetHandler(string key)
  • public virtual IHandler GetHandler(Type service)
  • public virtual IHandler[] GetHandlers(Type service)
  • public void GetObjectData(SerializationInfo info, StreamingContext context)
  • public object GetService(Type serviceType)
  • public T GetService<T>()
  • public virtual ISubSystem GetSubSystem(string key)
  • public virtual bool HasComponent(string key)
  • public virtual bool HasComponent(Type serviceType)
  • public IDisposable OptimizeDependencyResolution()
  • protected virtual void RaiseAddedAsChildKernel()
  • public virtual void RaiseComponentCreated(ComponentModel model, object instance)
  • public virtual void RaiseComponentDestroyed(ComponentModel model, object instance)
  • protected virtual void RaiseComponentModelCreated(ComponentModel model)
  • protected virtual void RaiseComponentRegistered(string key, IHandler handler)
  • protected virtual void RaiseComponentUnregistered(string key, IHandler handler)
  • protected virtual void RaiseDependencyResolving(ComponentModel client, DependencyModel model, object dependency)
  • public virtual void RaiseHandlerRegistered(IHandler handler)
  • public virtual void RaiseHandlersChanged()
  • protected virtual void RaiseRemovedAsChildKernel()
  • public IKernel Register(IRegistration[] registrations)
  • public void RegisterCustomDependencies(Type service, IDictionary dependencies)
  • public void RegisterCustomDependencies(Type service, object dependenciesAsAnonymousType)
  • public void RegisterCustomDependencies(string key, IDictionary dependencies)
  • public void RegisterCustomDependencies(string key, object dependenciesAsAnonymousType)
  • protected void RegisterHandler(string key, IHandler handler)
  • protected void RegisterHandler(string key, IHandler handler, bool skipRegistration)
  • public void RegisterHandlerForwarding(Type forwardedType, string name)
  • protected virtual void RegisterSubSystems()
  • public virtual void ReleaseComponent(object instance)
  • public virtual void RemoveChildKernel(IKernel childKernel)
  • public virtual bool RemoveComponent(string key)
  • public T Resolve<T>(IDictionary arguments)
  • public T Resolve<T>(object argumentsAsAnonymousType)
  • public T Resolve<T>()
  • public T Resolve<T>(string key)
  • public T Resolve<T>(string key, IDictionary arguments)
  • public object Resolve(Type service)
  • public object Resolve(Type service, IDictionary arguments)
  • public object Resolve(Type service, object argumentsAsAnonymousType)
  • public object Resolve(string key, IDictionary arguments)
  • public object Resolve(string key, object argumentsAsAnonymousType)
  • public virtual object Resolve(string key, Type service)
  • public virtual object Resolve(string key, Type service, IDictionary arguments)
  • public virtual object Resolve(string key, Type service, object argumentsAsAnonymousType)
  • public Array ResolveAll(Type service)
  • public Array ResolveAll(Type service, IDictionary arguments)
  • public Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • public TService[] ResolveAll<TService>(object argumentsAsAnonymousType)
  • public TService[] ResolveAll<TService>(IDictionary arguments)
  • public TService[] ResolveAll<TService>()
  • protected object ResolveComponent(IHandler handler)
  • protected object ResolveComponent(IHandler handler, Type service)
  • protected object ResolveComponent(IHandler handler, IDictionary additionalArguments)
  • protected object ResolveComponent(IHandler handler, Type service, IDictionary additionalArguments)
  • protected virtual IHandler WrapParentHandler(IHandler parentHandler)
• public sealed delegate DependencyDelegate : MulticastDelegate
  • public DependencyDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ComponentModel client, DependencyModel model, object dependency, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(ComponentModel client, DependencyModel model, object dependency)
• public sealed delegate HandlerDelegate : MulticastDelegate
  • public HandlerDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(IHandler handler, ref bool stateChanged, AsyncCallback callback, object object)
  • public virtual void EndInvoke(ref bool stateChanged, IAsyncResult result)
  • public virtual void Invoke(IHandler handler, ref bool stateChanged)
• public sealed delegate HandlersChangedDelegate : MulticastDelegate
  • public HandlersChangedDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ref bool stateChanged, AsyncCallback callback, object object)
  • public virtual void EndInvoke(ref bool stateChanged, IAsyncResult result)
  • public virtual void Invoke(ref bool stateChanged)
• public enum HandlerState
  • Valid = 0
  • WaitingDependency = 1
• public sealed delegate HandlerStateDelegate : MulticastDelegate
  • public HandlerStateDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(object source, EventArgs args, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(object source, EventArgs args)
• public interface IComponentActivator
  • object Create(CreationContext context)
  • void Destroy(object instance)
• public interface IComponentModelBuilder
  • IContributeComponentModelConstruction[] Contributors { get; }
  • void AddContributor(IContributeComponentModelConstruction contributor)
  • ComponentModel BuildModel(string key, Type service, Type classType, IDictionary extendedProperties)
  • void RemoveContributor(IContributeComponentModelConstruction contributor)
• public interface IConfigurationStore : ISubSystem
  • void AddBootstrapComponentConfiguration(string key, IConfiguration config)
  • void AddChildContainerConfiguration(string name, IConfiguration config)
  • void AddComponentConfiguration(string key, IConfiguration config)
  • void AddFacilityConfiguration(string key, IConfiguration config)
  • IConfiguration GetBootstrapComponentConfiguration(string key)
  • IConfiguration[] GetBootstrapComponents()
  • IConfiguration GetChildContainerConfiguration(string key)
  • IConfiguration GetComponentConfiguration(string key)
  • IConfiguration[] GetComponents()
  • IConfiguration[] GetConfigurationForChildContainers()
  • IConfiguration[] GetFacilities()
  • IConfiguration GetFacilityConfiguration(string key)
  • IResource GetResource(string resourceUri, IResource resource)
• public interface IDependencyResolver : ISubDependencyResolver
  • void AddSubResolver(ISubDependencyResolver subResolver)
  • void Initialize(DependencyDelegate resolving)
  • void RemoveSubResolver(ISubDependencyResolver subResolver)
• public interface IFacility
  • void Init(IKernel kernel, IConfiguration facilityConfig)
  • void Terminate()
• public interface IHandler : ISubDependencyResolver
  • ComponentModel ComponentModel { get; }
  • HandlerState CurrentState { get; }
  • Type Service { get; }
  • event HandlerStateDelegate OnHandlerStateChanged
  • void AddCustomDependencyValue(string key, object value)
  • bool HasCustomParameter(string key)
  • void Init(IKernel kernel)
  • bool Release(object instance)
  • void RemoveCustomDependencyValue(string key)
  • object Resolve(CreationContext context)
• public interface IHandlerFactory
  • IHandler Create(ComponentModel model)
  • IHandler CreateForwarding(IHandler target, Type forwardedType)
• public interface IHandlerSelector
  • bool HasOpinionAbout(string key, Type service)
  • IHandler SelectHandler(string key, Type service, IHandler[] handlers)
• public interface IKernel : IServiceProviderEx, IServiceProvider, IKernelEvents, IDisposable
  • IComponentModelBuilder ComponentModelBuilder { get; }
  • IConfigurationStore ConfigurationStore { get; set; }
  • GraphNode[] GraphNodes { get; }
  • IHandlerFactory HandlerFactory { get; }
  • object this[string key] { get; }
  • object this[Type service] { get; }
  • IKernel Parent { get; set; }
  • IProxyFactory ProxyFactory { get; set; }
  • IReleasePolicy ReleasePolicy { get; set; }
  • IDependencyResolver Resolver { get; }
  • void AddChildKernel(IKernel kernel)
  • 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)
  • void AddCustomComponent(ComponentModel model)
  • 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
  • IKernel AddFacility<T>(string key, Func<T, object> onCreate) where T : IFacility
  • IKernel AddFacility<T>() where T : IFacility
  • IKernel AddFacility<T>(Action<T> onCreate) where T : IFacility
  • IKernel AddFacility<T>(Func<T, object> onCreate) where T : IFacility
  • void AddHandlerSelector(IHandlerSelector selector)
  • void AddSubSystem(string key, ISubSystem subsystem)
  • IComponentActivator CreateComponentActivator(ComponentModel model)
  • IHandler[] GetAssignableHandlers(Type service)
  • IFacility[] GetFacilities()
  • IHandler GetHandler(string key)
  • IHandler GetHandler(Type service)
  • IHandler[] GetHandlers(Type service)
  • ISubSystem GetSubSystem(string key)
  • bool HasComponent(string key)
  • bool HasComponent(Type service)
  • void RaiseHandlerRegistered(IHandler handler)
  • void RaiseHandlersChanged()
  • IKernel Register(IRegistration[] registrations)
  • void RegisterCustomDependencies(Type service, IDictionary dependencies)
  • void RegisterCustomDependencies(Type service, object dependenciesAsAnonymousType)
  • void RegisterCustomDependencies(string key, IDictionary dependencies)
  • void RegisterCustomDependencies(string key, object dependenciesAsAnonymousType)
  • void RegisterHandlerForwarding(Type forwardedType, string name)
  • void ReleaseComponent(object instance)
  • void RemoveChildKernel(IKernel kernel)
  • bool RemoveComponent(string key)
  • object Resolve(Type service)
  • object Resolve(Type service, IDictionary arguments)
  • object Resolve(string key, IDictionary arguments)
  • object Resolve(Type service, object argumentsAsAnonymousType)
  • object Resolve(string key, object argumentsAsAnonymousType)
  • object Resolve(string key, Type service)
  • T Resolve<T>(IDictionary arguments)
  • T Resolve<T>(object argumentsAsAnonymousType)
  • T Resolve<T>()
  • T Resolve<T>(string key)
  • T Resolve<T>(string key, IDictionary arguments)
  • object Resolve(string key, Type service, IDictionary arguments)
  • Array ResolveAll(Type service)
  • Array ResolveAll(Type service, IDictionary arguments)
  • Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • TService[] ResolveAll<TService>()
  • TService[] ResolveAll<TService>(IDictionary arguments)
  • TService[] ResolveAll<TService>(object argumentsAsAnonymousType)
• public interface IKernelEvents
  • event EventHandler AddedAsChildKernel
  • event ComponentInstanceDelegate ComponentCreated
  • event ComponentInstanceDelegate ComponentDestroyed
  • event ComponentModelDelegate ComponentModelCreated
  • event ComponentDataDelegate ComponentRegistered
  • event ComponentDataDelegate ComponentUnregistered
  • event DependencyDelegate DependencyResolving
  • event HandlerDelegate HandlerRegistered
  • event HandlersChangedDelegate HandlersChanged
  • event EventHandler RemovedAsChildKernel
• public interface ILifestyleManager : IDisposable
  • void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
  • bool Release(object instance)
  • object Resolve(CreationContext context)
• public interface INamingSubSystem : ISubSystem
  • int ComponentCount { get; }
  • void AddHandlerSelector(IHandlerSelector selector)
  • bool Contains(string key)
  • bool Contains(Type service)
  • IHandler[] GetAssignableHandlers(Type service)
  • IHandler GetHandler(string key)
  • IHandler GetHandler(Type service)
  • IHandler GetHandler(string key, Type service)
  • IHandler[] GetHandlers(string query)
  • IHandler[] GetHandlers(Type service)
  • IHandler[] GetHandlers()
  • IDictionary<string, IHandler> GetKey2Handler()
  • IDictionary<Type, IHandler> GetService2Handler()
  • void Register(string key, IHandler handler)
  • void UnRegister(string key)
  • void UnRegister(Type service)
• public interface IProxyFactory
  • void AddInterceptorSelector(IModelInterceptorsSelector selector)
  • object Create(IKernel kernel, object instance, ComponentModel model, CreationContext context, object[] constructorArguments)
  • bool RequiresTargetInstance(IKernel kernel, ComponentModel model)
  • bool ShouldCreateProxy(ComponentModel model)
• public interface IReleasePolicy : IDisposable
  • bool HasTrack(object instance)
  • void Release(object instance)
  • void Track(object instance, Burden burden)
• public interface ISubDependencyResolver
  • bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
• public interface ISubSystem
  • void Init(IKernel kernel)
  • void Terminate()
• public class KernelException : ApplicationException
  • public KernelException(string message)
  • public KernelException(string message, Exception innerException)
  • public KernelException(SerializationInfo info, StreamingContext context)
• public abstract class SubSystemConstants
  • public static readonly string ConfigurationStoreKey
  • public static readonly string ConversionManagerKey
  • public static readonly string NamingKey
  • public static readonly string ResourceKey
  • protected SubSystemConstants()
• 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 IKernel Kernel { get; }
  • public ComponentModel Model { get; }
  • public ComponentInstanceDelegate OnCreation { get; }
  • public ComponentInstanceDelegate OnDestruction { get; }
  • public AbstractComponentActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public virtual object Create(CreationContext context)
  • public virtual void Destroy(object instance)
  • protected abstract object InternalCreate(CreationContext context)
  • protected abstract void InternalDestroy(object instance)
• public class ComponentActivatorException : ApplicationException
  • public ComponentActivatorException(string message)
  • public ComponentActivatorException(string message, Exception innerException)
  • public ComponentActivatorException(SerializationInfo info, StreamingContext context)
• public class DefaultComponentActivator : AbstractComponentActivator
  • public DefaultComponentActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • protected virtual void ApplyCommissionConcerns(object instance)
  • protected virtual void ApplyConcerns(object[] steps, object instance)
  • protected virtual void ApplyDecommissionConcerns(object instance)
  • protected virtual bool CanSatisfyDependency(CreationContext context, DependencyModel dep)
  • protected virtual object[] CreateConstructorArguments(ConstructorCandidate constructor, CreationContext context, out Type signature)
  • protected virtual object CreateInstance(CreationContext context, object[] arguments, Type[] signature)
  • protected virtual object Instantiate(CreationContext context)
  • protected virtual ConstructorCandidate SelectEligibleConstructor(CreationContext context)
  • protected virtual void SetUpProperties(object instance, CreationContext context)
• public class ExternalInstanceActivator : AbstractComponentActivator
  • public ExternalInstanceActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class WebUserControlComponentActivator : DefaultComponentActivator
  • public WebUserControlComponentActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• 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.Exceptions

• public class CircularDependencyException : Exception
  • public CircularDependencyException()
  • public CircularDependencyException(string message)
  • public CircularDependencyException(string message, Exception innerException)
  • protected CircularDependencyException(SerializationInfo info, StreamingContext context)

Castle.MicroKernel.Facilities

• public abstract class AbstractFacility : IFacility, IDisposable
  • public IConfiguration FacilityConfig { get; }
  • public IKernel Kernel { get; }
  • protected AbstractFacility()
  • public virtual void Dispose()
  • protected abstract void Init()
  • public void Init(IKernel kernel, IConfiguration facilityConfig)
  • public void Terminate()
• public class FacilityException : ApplicationException
  • public FacilityException(string message)
  • public FacilityException(string message, Exception innerException)
  • public FacilityException(SerializationInfo info, StreamingContext context)
• public abstract class AbstractFacility : IFacility, IDisposable
• public class FacilityException : Exception

Castle.MicroKernel.Facilities.OnCreate

• public sealed delegate OnCreateActionDelegate : MulticastDelegate
  • public OnCreateActionDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, object item, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(IKernel kernel, object item)
• public sealed delegate OnCreateActionDelegate<T> : MulticastDelegate
  • public OnCreateActionDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, T item, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(IKernel kernel, T item)
• public class OnCreateFacility : AbstractFacility
  • public const string OnCreatePropertyKey = "oncreate"
  • public OnCreateFacility()
  • protected virtual void HandleComponentCreated(ComponentModel model, object instance)

Castle.MicroKernel.Handlers

• public abstract class AbstractHandler : MarshalByRefObject, IHandler, ISubDependencyResolver, IExposeDependencyInfo, IDisposable
  • protected ILifestyleManager lifestyleManager
  • public ComponentModel ComponentModel { get; }
  • public HandlerState CurrentState { get; }
  • protected IDictionary<string, DependencyModel> DependenciesByKey { get; }
  • protected IDictionary<Type, DependencyModel> DependenciesByService { get; }
  • protected IKernel Kernel { get; }
  • public Type Service { get; }
  • public event HandlerStateDelegate OnHandlerStateChanged
  • public AbstractHandler(ComponentModel model)
  • public void AddCustomDependencyValue(string key, object value)
  • protected void AddDependency(DependencyModel dependency)
  • public virtual bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • protected virtual ILifestyleManager CreateLifestyleManager(IComponentActivator activator)
  • protected void DependencySatisfied(ref bool stateChanged)
  • public virtual void Dispose()
  • protected virtual void EnsureDependenciesCanBeSatisfied()
  • public bool HasCustomParameter(string key)
  • public virtual void Init(IKernel kernel)
  • public string ObtainDependencyDetails(IList dependenciesChecked)
  • protected void OnAddedAsChildKernel(object sender, EventArgs e)
  • public abstract bool Release(object instance)
  • public void RemoveCustomDependencyValue(string key)
  • public abstract object Resolve(CreationContext context)
  • public virtual object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • protected void SetNewState(HandlerState newState)
• public class DefaultGenericHandler : AbstractHandler
  • public DefaultGenericHandler(ComponentModel model)
  • protected IHandler GetSubHandler(CreationContext context, Type genericType)
• public class DefaultHandler : AbstractHandler
  • public DefaultHandler(ComponentModel model)
  • protected void AssertNotWaitingForDependency()
• public class DefaultHandlerFactory : IHandlerFactory
  • public DefaultHandlerFactory(IKernel kernel)
  • public virtual IHandler Create(ComponentModel model)
  • public IHandler CreateForwarding(IHandler target, Type forwardedType)
• public class ForwardingHandler : IHandler, ISubDependencyResolver
  • public ComponentModel ComponentModel { get; }
  • public HandlerState CurrentState { get; }
  • public Type Service { get; }
  • public IHandler Target { get; }
  • public event HandlerStateDelegate OnHandlerStateChanged
  • public ForwardingHandler(IHandler target, Type forwardedType)
  • public void AddCustomDependencyValue(string key, object value)
  • public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public bool HasCustomParameter(string key)
  • public void Init(IKernel kernel)
  • public bool Release(object instance)
  • public void RemoveCustomDependencyValue(string key)
  • public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public object Resolve(CreationContext context)
• public class HandlerException : ApplicationException
  • public HandlerException(string message)
  • public HandlerException(SerializationInfo info, StreamingContext context)
• public interface IExposeDependencyInfo
  • string ObtainDependencyDetails(IList dependenciesChecked)
• public class ParentHandlerWithChildResolver : IHandler, ISubDependencyResolver, IDisposable
  • public virtual ComponentModel ComponentModel { get; }
  • public virtual HandlerState CurrentState { get; }
  • public Type Service { get; }
  • public event HandlerStateDelegate OnHandlerStateChanged
  • public ParentHandlerWithChildResolver(IHandler parentHandler, ISubDependencyResolver childResolver)
  • public virtual void AddCustomDependencyValue(string key, object value)
  • public virtual bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public virtual bool HasCustomParameter(string key)
  • public virtual void Init(IKernel kernel)
  • protected virtual void RaiseHandlerStateChanged(object s, EventArgs e)
  • public virtual bool Release(object instance)
  • public virtual void RemoveCustomDependencyValue(string key)
  • public virtual object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public virtual object Resolve(CreationContext context)
• 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 : ILifecycleConcern
  • public static DisposalConcern Instance { get; }
  • protected DisposalConcern()
  • public void Apply(ComponentModel model, object component)
• public interface ILifecycleConcern
  • void Apply(ComponentModel model, object component)
• public class InitializationConcern : ILifecycleConcern
  • public static InitializationConcern Instance { get; }
  • protected InitializationConcern()
  • public void Apply(ComponentModel model, object component)
• public class SupportInitializeConcern : ILifecycleConcern
  • public static SupportInitializeConcern Instance { get; }
  • protected SupportInitializeConcern()
  • public void Apply(ComponentModel model, object component)
• 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
  • protected IComponentActivator ComponentActivator { get; }
  • protected IKernel Kernel { get; }
  • protected ComponentModel Model { get; }
  • protected AbstractLifestyleManager()
  • public abstract void Dispose()
  • public virtual void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
  • public virtual bool Release(object instance)
  • public virtual object Resolve(CreationContext context)
• public class PerThreadLifestyleManager : AbstractLifestyleManager, IDeserializationCallback
  • public PerThreadLifestyleManager()
  • public void OnDeserialization(object sender)
• public class PerWebRequestLifestyleManager : AbstractLifestyleManager
  • public PerWebRequestLifestyleManager()
• public class PerWebRequestLifestyleModule : IHttpModule
  • public PerWebRequestLifestyleModule()
  • protected void Application_EndRequest(object sender, EventArgs e)
  • public void Dispose()
  • public void Init(HttpApplication context)
• public class PoolableLifestyleManager : AbstractLifestyleManager
  • public PoolableLifestyleManager(int initialSize, int maxSize)
  • protected IPool CreatePool(int initialSize, int maxSize)
• public class SingletonLifestyleManager : AbstractLifestyleManager
  • public SingletonLifestyleManager()
• public class TransientLifestyleManager : AbstractLifestyleManager
  • public TransientLifestyleManager()
• 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 DefaultPool(int initialsize, int maxsize, IComponentActivator componentActivator)
  • public virtual void Dispose()
  • public virtual bool Release(object instance)
  • public virtual object Request(CreationContext context)
• public class DefaultPoolFactory : IPoolFactory
  • public DefaultPoolFactory()
  • public IPool Create(int initialsize, int maxSize, IComponentActivator activator)
• public interface IPool : IDisposable
  • bool Release(object instance)
  • object Request(CreationContext context)
• public interface IPoolFactory
  • IPool Create(int initialsize, int maxSize, IComponentActivator activator)
• public class PoolException : ApplicationException
  • public PoolException(string message)
  • public PoolException(SerializationInfo info, StreamingContext context)
• 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 class DefaultComponentModelBuilder : IComponentModelBuilder
  • public IContributeComponentModelConstruction[] Contributors { get; }
  • public DefaultComponentModelBuilder(IKernel kernel)
  • public void AddContributor(IContributeComponentModelConstruction contributor)
  • public ComponentModel BuildModel(string key, Type service, Type classType, IDictionary extendedProperties)
  • protected virtual void InitializeContributors()
  • public void RemoveContributor(IContributeComponentModelConstruction contributor)
• public interface IContributeComponentModelConstruction
  • void ProcessModel(IKernel kernel, ComponentModel model)
• 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 ComponentActivatorInspector()
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
  • protected virtual bool ReadComponentActivatorFromConfiguration(ComponentModel model)
  • protected virtual void ReadComponentActivatorFromType(ComponentModel model)
  • protected virtual void ValidateComponentActivator(Type customComponentActivator)
• public class ComponentProxyInspector : IContributeComponentModelConstruction
  • public ComponentProxyInspector()
  • protected virtual ComponentProxyBehaviorAttribute GetProxyBehaviorFromType(Type implementation)
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
  • protected virtual void ReadProxyBehavior(IKernel kernel, ComponentModel model)
• public class ConfigurationModelInspector : IContributeComponentModelConstruction
  • public ConfigurationModelInspector()
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
• public class ConfigurationParametersInspector : IContributeComponentModelConstruction
  • public ConfigurationParametersInspector()
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
• public class ConstructorDependenciesModelInspector : IContributeComponentModelConstruction
  • public ConstructorDependenciesModelInspector()
  • protected virtual ConstructorCandidate CreateConstructorCandidate(ComponentModel model, ConstructorInfo constructor)
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
• public class GenericInspector : IContributeComponentModelConstruction
  • public GenericInspector()
  • public void ProcessModel(IKernel kernel, ComponentModel model)
• public class InterceptorInspector : IContributeComponentModelConstruction
  • public InterceptorInspector()
  • protected void AddInterceptor(InterceptorReference interceptorRef, InterceptorReferenceCollection interceptors)
  • protected virtual void CollectFromAttributes(ComponentModel model)
  • protected virtual void CollectFromConfiguration(ComponentModel model)
  • protected DependencyModel CreateDependencyModel(InterceptorReference interceptor)
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
• public class LifecycleModelInspector : IContributeComponentModelConstruction
  • public LifecycleModelInspector()
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
• public class LifestyleModelInspector : IContributeComponentModelConstruction
  • public LifestyleModelInspector()
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
  • protected virtual bool ReadLifestyleFromConfiguration(ComponentModel model)
  • protected virtual void ReadLifestyleFromType(ComponentModel model)
• public abstract class MethodMetaInspector : IContributeComponentModelConstruction
  • protected virtual bool ShouldUseMetaModel { get; }
  • protected MethodMetaInspector()
  • protected virtual bool IsValidMeta(ComponentModel model, MethodMetaModel metaModel)
  • protected abstract string ObtainNodeName()
  • protected virtual void ProcessMeta(ComponentModel model, MethodInfo[] methods, MethodMetaModel metaModel)
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
• public class PropertiesDependenciesModelInspector : IContributeComponentModelConstruction
  • public PropertiesDependenciesModelInspector()
  • protected virtual void InspectProperties(ComponentModel model)
  • public virtual void ProcessModel(IKernel kernel, ComponentModel model)
• 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
  • bool HasInterceptors(ComponentModel model)
  • InterceptorReference[] SelectInterceptors(ComponentModel model)
• public interface IProxyHook
  • void MethodsInspected()
  • void NonVirtualMemberNotification(Type type, MemberInfo memberInfo)
  • bool ShouldInterceptMethod(Type type, MethodInfo memberInfo)
• public class NotSupportedProxyFactory : IProxyFactory
  • public NotSupportedProxyFactory()
  • public void AddInterceptorSelector(IModelInterceptorsSelector selector)
  • public object Create(IKernel kernel, object instance, ComponentModel mode, CreationContext context, object[] constructorArguments)
  • public bool RequiresTargetInstance(IKernel kernel, ComponentModel model)
  • public bool ShouldCreateProxy(ComponentModel model)
• public abstract class ProxyConstants
  • public static readonly string ProxyOptionsKey
  • protected ProxyConstants()
• public class ProxyOptions
  • public Type[] AdditionalInterfaces { get; }
  • public bool AllowChangeTarget { get; set; }
  • public IProxyHook Hook { get; set; }
  • public object[] MixIns { get; }
  • public bool OmitTarget { get; set; }
  • public IInterceptorSelector Selector { get; set; }
  • public bool UseMarshalByRefAsBaseClass { get; set; }
  • public bool UseSingleInterfaceProxy { get; set; }
  • public ProxyOptions()
  • public void AddAdditionalInterfaces(Type[] interfaces)
  • public void AddMixIns(object[] mixIns)
• public abstract class ProxyUtil
  • protected ProxyUtil()
  • public static object GetUnproxiedInstance(object instance)
  • public static Type GetUnproxiedType(object instance)
  • public static ProxyOptions ObtainProxyOptions(ComponentModel model, bool createOnDemand)
• public interface IModelInterceptorsSelector
• public class NotSupportedProxyFactory : IProxyFactory
• public abstract class ProxyConstants
• public class ProxyOptions
• public static class ProxyOptionsUtil

Castle.MicroKernel.Registration

• public abstract class AbstractPropertyDescriptor<S> : ComponentDescriptor<S>
  • protected AbstractPropertyDescriptor(Property[] properties)
  • protected AbstractPropertyDescriptor(IDictionary dictionary)
  • protected abstract void ApplyProperty(IKernel kernel, ComponentModel model, string key, object value, Property property)
• 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 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 Attrib : Node
  • public static NamedAttribute ForName(string name)
• public class AttributeDescriptor<S> : ComponentDescriptor<S>
  • public AttributeDescriptor(string name, string value)
• public class AttributeKeyDescriptor<S>
  • public AttributeKeyDescriptor(ComponentRegistration<S> component, string name)
  • public ComponentRegistration<S> Eq(object value)
• public class BasedOnDescriptor : IRegistration
  • public ServiceDescriptor WithService { get; }
  • public FromDescriptor AllowMultipleMatches()
  • public BasedOnDescriptor BasedOn<T>()
  • public BasedOnDescriptor BasedOn(Type basedOn)
  • public BasedOnDescriptor Configure(Action<ComponentRegistration> configurer)
  • public BasedOnDescriptor Configure(ConfigureDelegate configurer)
  • public BasedOnDescriptor ConfigureFor<T>(Action<ComponentRegistration> configurer)
  • public BasedOnDescriptor ConfigureFor<T>(ConfigureDelegate configurer)
  • public BasedOnDescriptor If(Predicate<Type> ifFilter)
  • public BasedOnDescriptor Unless(Predicate<Type> unlessFilter)
  • public BasedOnDescriptor Where(Predicate<Type> accepted)
• public abstract class Child
  • protected Child()
  • public static NamedChild ForName(string name)
• public class ComplexChild : Node
• public static class Component
  • public static ComponentRegistration For(Type serviceType)
  • public static ComponentRegistration For(Type[] serviceTypes)
  • public static ComponentRegistration For(IEnumerable<Type> serviceTypes)
  • public static ComponentRegistration<S> For<S>()
  • public static ComponentRegistration<S> For<S, F>()
  • public static ComponentRegistration<S> For<S, F1, F2>()
  • public static ComponentRegistration<S> For<S, F1, F2, F3>()
  • public static ComponentRegistration<S> For<S, F1, F2, F3, F4>()
  • public static ComponentRegistration For(ComponentModel model)
  • public static Predicate<Type> IsInNamespace(string namespace)
  • public static Predicate<Type> IsInSameNamespaceAs(Type type)
  • public static Predicate<Type> IsInSameNamespaceAs<T>()
  • public static bool ServiceAlreadyRegistered(IKernel kernel, ComponentModel model)
• public abstract class ComponentDescriptor : ComponentDescriptor<object>
  • protected ComponentDescriptor()
• public abstract class ComponentDescriptor<S>
  • protected ComponentDescriptor()
• public sealed delegate ComponentFilter : MulticastDelegate
  • public ComponentFilter(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, ComponentModel model, AsyncCallback callback, object object)
  • public virtual bool EndInvoke(IAsyncResult result)
  • public virtual bool Invoke(IKernel kernel, ComponentModel model)
• public class ComponentInstanceDescriptior<S> : ComponentDescriptor<S>
  • public ComponentInstanceDescriptior(object instance)
• public class ComponentRegistration : ComponentRegistration<object>
  • public ComponentRegistration()
  • public ComponentRegistration(Type serviceType, Type[] forwaredTypes)
  • public ComponentRegistration(ComponentModel componentModel)
  • public ComponentRegistration For(Type serviceType, Type[] forwaredTypes)
• public class ComponentRegistration<S> : IRegistration
  • public Type[] ForwardedTypes { get; }
  • public Type Implementation { get; }
  • public LifestyleGroup<S> LifeStyle { get; }
  • public string Name { get; }
  • public ProxyGroup<S> Proxy { get; }
  • public Type ServiceType { get; protected set; }
  • public ComponentRegistration()
  • protected ComponentRegistration(ComponentModel componentModel)
  • public ComponentRegistration<S> ActAs(object[] actors)
  • public ComponentRegistration<S> Activator<A>() where A : IComponentActivator
  • public ComponentRegistration<S> AddAttributeDescriptor(string key, string value)
  • public ComponentRegistration<S> AddDescriptor(ComponentDescriptor<S> descriptor)
  • public AttributeKeyDescriptor<S> Attribute(string key)
  • public ComponentRegistration<S> Configuration(Node[] configNodes)
  • public ComponentRegistration<S> Configuration(IConfiguration configuration)
  • public ComponentRegistration<S> CustomDependencies(Property[] dependencies)
  • public ComponentRegistration<S> CustomDependencies(IDictionary dependencies)
  • public ComponentRegistration<S> CustomDependencies(object dependencies)
  • public ComponentRegistration<S> DependsOn(Property[] dependencies)
  • public ComponentRegistration<S> DependsOn(IDictionary dependencies)
  • public ComponentRegistration<S> DependsOn(object anonymous)
  • public ComponentRegistration<S> ExtendedProperties(Property[] properties)
  • public ComponentRegistration<S> ExtendedProperties(object anonymous)
  • public ComponentRegistration<S> Forward(Type[] types)
  • public ComponentRegistration<S> Forward<F>()
  • public ComponentRegistration<S> Forward<F1, F2>()
  • public ComponentRegistration<S> Forward<F1, F2, F3>()
  • public ComponentRegistration<S> Forward<F1, F2, F3, F4>()
  • public ComponentRegistration<S> Forward(IEnumerable<Type> types)
  • public ComponentRegistration<S> If(ComponentFilter ifFilter)
  • public ComponentRegistration<S> ImplementedBy<C>() where C : S
  • public ComponentRegistration<S> ImplementedBy(Type type)
  • public ComponentRegistration<S> Instance(S instance)
  • public InterceptorGroup<S> Interceptors(InterceptorReference[] interceptors)
  • public ComponentRegistration<S> Named(string name)
  • public ComponentRegistration<S> OnCreate(OnCreateActionDelegate<S>[] actions)
  • public ComponentRegistration<S> OverWrite()
  • public ComponentRegistration<S> Parameters(Parameter[] parameters)
  • public ComponentRegistration<S> SelectInterceptorsWith(IInterceptorSelector selector)
  • public ComponentRegistration<S> ServiceOverrides(ServiceOverride[] overrides)
  • public ComponentRegistration<S> ServiceOverrides(IDictionary overrides)
  • public ComponentRegistration<S> ServiceOverrides(object anonymous)
  • public ComponentRegistration<S> Startable()
  • public ComponentRegistration<S> StartUsingMethod(string startMethod)
  • public ComponentRegistration<S> StopUsingMethod(string stopMethod)
  • public ComponentRegistration<S> Unless(ComponentFilter unlessFilter)
  • public ComponentRegistration<S> UsingFactory<U, V>(Converter<U, V> factory) where V : S
  • public ComponentRegistration<S> UsingFactoryMethod<T>(Function<T> factoryMethod) where T : S
  • public ComponentRegistration<S> UsingFactoryMethod<T>(Converter<IKernel, T> factoryMethod) where T : S
  • public ComponentRegistration<S> UsingFactoryMethod<T>(Func<IKernel, CreationContext, T> factoryMethod) where T : S
• public class CompoundChild : Node
• public class ConfigurationDescriptor<S> : ComponentDescriptor<S>
  • public ConfigurationDescriptor(Node[] configNodes)
  • public ConfigurationDescriptor(IConfiguration configuration)
• public sealed delegate ConfigureDelegate : MulticastDelegate
  • public ConfigureDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ComponentRegistration registration, AsyncCallback callback, object object)
  • public virtual object EndInvoke(IAsyncResult result)
  • public virtual object Invoke(ComponentRegistration registration)
• public class ConfigureDescriptor
  • public ConfigureDescriptor(BasedOnDescriptor basedOn, Action<ComponentRegistration> configurer)
  • public ConfigureDescriptor(BasedOnDescriptor basedOn, Type baseType, Action<ComponentRegistration> configurer)
  • public virtual void Apply(ComponentRegistration registration)
  • public BasedOnDescriptor Configure(Action<ComponentRegistration> configurer)
  • public BasedOnDescriptor Configure(ConfigureDelegate configurer)
  • public BasedOnDescriptor ConfigureFor<T>(Action<ComponentRegistration> configurer)
  • public BasedOnDescriptor ConfigureFor<T>(ConfigureDelegate configurer)
• public class CustomDependencyDescriptor<S> : AbstractPropertyDescriptor<S>
  • public CustomDependencyDescriptor(Property[] properties)
  • public CustomDependencyDescriptor(IDictionary dictionary)
  • public CustomDependencyDescriptor(object overridesAsAnonymousType)
• public class ExtendedPropertiesDescriptor<S> : AbstractPropertyDescriptor<S>
  • public ExtendedPropertiesDescriptor(Property[] properties)
  • public ExtendedPropertiesDescriptor(IDictionary dictionary)
  • public ExtendedPropertiesDescriptor(object overridesAsAnonymousType)
• public class FromAssemblyDescriptor : FromDescriptor
  • public FromAssemblyDescriptor IncludeNonPublicTypes()
• public abstract class FromDescriptor : IRegistration
  • public FromDescriptor AllowMultipleMatches()
  • public BasedOnDescriptor BasedOn<T>()
  • public BasedOnDescriptor BasedOn(Type basedOn)
  • protected abstract IEnumerable<Type> SelectedTypes(IKernel kernel)
  • public BasedOnDescriptor Where(Predicate<Type> accepted)
• public class FromTypesDescriptor : FromDescriptor
• public sealed delegate Function<T> : MulticastDelegate
  • public Function(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual T EndInvoke(IAsyncResult result)
  • public virtual T Invoke()
• public class GenericFactory<T>
  • public GenericFactory(Function<T> factoryMethod)
  • public T Create()
• public class GenericFactoryWithContext<T>
  • public GenericFactoryWithContext(Func<IKernel, CreationContext, T> factoryMethod)
  • public T Create(IKernel kernel, CreationContext context)
• public class GenericFactoryWithKernel<T>
  • public GenericFactoryWithKernel(KernelToT<T> factoryMethod, IKernel kernel)
  • public T Create()
• public interface IRegistration
  • void Register(IKernel kernel)
• public class KernelToT<T>
  • public KernelToT(Converter<IKernel, T> fun)
  • public T Call(IKernel kernel)
• public class LifestyleDescriptor<S> : ComponentDescriptor<S>
  • public LifestyleDescriptor(LifestyleType lifestyle)
  • protected virtual void ApplyLifestyleDetails(IConfiguration configuration)
• public class NamedAttribute
  • public Attrib Eq(string value)
  • public Attrib Eq(object value)
• public class NamedChild : Node
  • public SimpleChild Eq(string value)
  • public SimpleChild Eq(object value)
  • public ComplexChild Eq(IConfiguration configNode)
  • public CompoundChild Eq(Node[] childNodes)
• public abstract class Node
  • protected string Name { get; }
  • protected Node(string name)
  • public abstract void ApplyTo(IConfiguration configuration)
• public class Parameter
  • public IConfiguration ConfigNode { get; }
  • public string Key { get; }
  • public string Value { get; }
  • public static ParameterKey ForKey(string key)
• public class ParameterKey
  • public string Name { get; }
  • public Parameter Eq(string value)
  • public Parameter Eq(IConfiguration configNode)
• public class ParametersDescriptor<S> : ComponentDescriptor<S>
  • public ParametersDescriptor(Parameter[] parameters)
• public class Property
  • public string Key { get; }
  • public object Value { get; }
  • public static PropertyKey ForKey(string key)
• public class PropertyKey
  • public string Name { get; }
  • public Property Eq(object value)
• public abstract class RegistrationGroup<S>
  • public ComponentRegistration<S> Registration { get; }
  • public RegistrationGroup(ComponentRegistration<S> registration)
  • protected ComponentRegistration<S> AddAttributeDescriptor(string name, string value)
  • protected ComponentRegistration<S> AddDescriptor(ComponentDescriptor<S> descriptor)
• public class ServiceDescriptor
  • public sealed delegate ServiceSelector : MulticastDelegate
  • public BasedOnDescriptor Base()
  • public BasedOnDescriptor FirstInterface()
  • public BasedOnDescriptor FromInterface(Type implements)
  • public BasedOnDescriptor FromInterface()
  • public BasedOnDescriptor Select(ServiceSelector selector)
  • public BasedOnDescriptor Select(IEnumerable<Type> types)
• public class ServiceOverride : Property
  • public Type Type { get; }
  • public static ServiceOverrideKey ForKey(string key)
• public class ServiceOverrideDescriptor<S> : AbstractPropertyDescriptor<S>
  • public ServiceOverrideDescriptor(ServiceOverride[] overrides)
  • public ServiceOverrideDescriptor(IDictionary dictionary)
  • public ServiceOverrideDescriptor(object overridesAsAnonymousType)
• public class ServiceOverrideKey
  • public string Name { get; }
  • public ServiceOverride Eq(string value)
  • public ServiceOverride Eq(string[] value)
  • public ServiceOverride Eq<V>(string[] value)
  • public ServiceOverride Eq(IEnumerable<string> value)
  • public ServiceOverride Eq<V>(IEnumerable<string> value)
• public class SimpleChild : Node
• 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.Facilities

• public class OnCreateComponentDescriptor<S> : ComponentDescriptor<S>
  • public OnCreateComponentDescriptor(OnCreateActionDelegate<S>[] actions)

Castle.MicroKernel.Registration.Interceptor

• public class InterceptorDescriptor<S> : ComponentDescriptor<S>
  • public enum Where<S>
  • public InterceptorDescriptor(InterceptorReference[] interceptors, Where<S> where)
  • public InterceptorDescriptor(InterceptorReference[] interceptors, int insertIndex)
  • public InterceptorDescriptor(InterceptorReference[] interceptors)
• public class InterceptorGroup<S> : RegistrationGroup<S>
  • public ComponentRegistration<S> Anywhere { get; }
  • public ComponentRegistration<S> First { get; }
  • public ComponentRegistration<S> Last { get; }
  • public InterceptorGroup(ComponentRegistration<S> registration, InterceptorReference[] interceptors)
  • public ComponentRegistration<S> AtIndex(int index)
  • public InterceptorGroup<S> SelectedWith(IInterceptorSelector selector)
• public class InterceptorSelectorDescriptor<S> : ComponentDescriptor<S>
  • public InterceptorSelectorDescriptor(IInterceptorSelector selector)
• public class InterceptorGroup<S> : RegistrationGroup<S>

Castle.MicroKernel.Registration.Lifestyle

• public class Custom<S> : LifestyleDescriptor<S>
  • public Custom(Type customLifestyleType)
• public class LifestyleGroup<S> : RegistrationGroup<S>
  • public ComponentRegistration<S> PerThread { get; }
  • public ComponentRegistration<S> PerWebRequest { get; }
  • public ComponentRegistration<S> Pooled { get; }
  • public ComponentRegistration<S> Singleton { get; }
  • public ComponentRegistration<S> Transient { get; }
  • public LifestyleGroup(ComponentRegistration<S> registration)
  • public ComponentRegistration<S> Custom(Type customLifestyleType)
  • public ComponentRegistration<S> Custom<L>() where L : ILifestyleManager
  • public ComponentRegistration<S> Is(LifestyleType type)
  • public ComponentRegistration<S> PooledWithSize(int? initialSize, int? maxSize)
• public class PerThread<S> : LifestyleDescriptor<S>
  • public PerThread()
• public class PerWebRequest<S> : LifestyleDescriptor<S>
  • public PerWebRequest()
• public class Pooled<S> : LifestyleDescriptor<S>
  • public Pooled()
  • public Pooled(int? initialSize, int? maxSize)
• public class Singleton<S> : LifestyleDescriptor<S>
  • public Singleton()
• public class Transient<S> : LifestyleDescriptor<S>
  • public Transient()
• public class LifestyleGroup<TService> : RegistrationGroup<TService>

Castle.MicroKernel.Registration.Proxy

• public class ProxyGroup<S> : RegistrationGroup<S>
  • public ComponentRegistration<S> AsMarshalByRefClass { get; }
  • public ComponentRegistration<S> UsingSingleInterface { get; }
  • public ProxyGroup(ComponentRegistration<S> registration)
  • public ComponentRegistration<S> AdditionalInterfaces(Type[] interfaces)
  • public ComponentRegistration<S> MixIns(object[] mixIns)
• public class ProxyInterfaces<S> : ComponentDescriptor<S>
  • public ProxyInterfaces(Type[] interfaces)
• public class ProxyMixIns<S> : ComponentDescriptor<S>
  • public ProxyMixIns(object[] mixIns)
• public class ItemRegistration<TItem>
• public class MixinRegistration : IEnumerable<IReference<object>>, IEnumerable
• public class ProxyGroup<S> : RegistrationGroup<S>

Castle.MicroKernel.Releasers

• public class AllComponentsReleasePolicy : IReleasePolicy, IDisposable
  • public AllComponentsReleasePolicy()
  • public void Dispose()
  • public bool HasTrack(object instance)
  • public void Release(object instance)
  • public virtual void Track(object instance, Burden burden)
• public class LifecycledComponentsReleasePolicy : AllComponentsReleasePolicy
  • public LifecycledComponentsReleasePolicy()
• public class NoTrackingReleasePolicy : IReleasePolicy, IDisposable
  • public NoTrackingReleasePolicy()
  • public void Dispose()
  • public bool HasTrack(object instance)
  • public void Release(object instance)
  • public void Track(object instance, Burden burden)
• public class LifecycledComponentsReleasePolicy : IReleasePolicy, IDisposable
• public class NoTrackingReleasePolicy : IReleasePolicy, IDisposable

Castle.MicroKernel.Resolvers

• public class DefaultDependencyResolver : IDependencyResolver, ISubDependencyResolver
  • public DefaultDependencyResolver(IKernel kernel)
  • public void AddSubResolver(ISubDependencyResolver subResolver)
  • public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • protected virtual bool CanResolveParameterDependency(ComponentModel model, DependencyModel dependency)
  • protected virtual bool CanResolveServiceDependency(CreationContext context, ComponentModel model, DependencyModel dependency)
  • protected virtual string ExtractComponentKey(string keyValue, string name)
  • public void Initialize(DependencyDelegate dependencyDelegate)
  • protected virtual ParameterModel ObtainParameterModelMatchingDependency(DependencyModel dependency, ComponentModel model)
  • public void RemoveSubResolver(ISubDependencyResolver subResolver)
  • public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • protected virtual object ResolveParameterDependency(CreationContext context, ComponentModel model, DependencyModel dependency)
  • protected virtual object ResolveServiceDependency(CreationContext context, ComponentModel model, DependencyModel dependency)
• public class DependencyResolverException : ApplicationException
  • public DependencyResolverException(string message)
  • public DependencyResolverException(SerializationInfo info, StreamingContext context)
• public interface ILazyComponentLoader
  • IRegistration Load(string key, Type service)
• public class DefaultDependencyResolver : IDependencyResolver, ISubDependencyResolver
• public class DependencyResolverException : Exception
• public interface ILazyComponentLoader
• public class LazyOfTComponentLoader : ILazyComponentLoader

Castle.MicroKernel.Resolvers.SpecializedResolvers

• public class ArrayResolver : ISubDependencyResolver
  • public ArrayResolver(IKernel kernel)
  • public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
• public class ListResolver : ISubDependencyResolver
  • public ListResolver(IKernel kernel)
  • public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
• public class ArrayResolver : CollectionResolver
• public class CollectionResolver : ISubDependencyResolver
• public class ListResolver : CollectionResolver

Castle.MicroKernel.SubSystems.Configuration

• public class DefaultConfigurationStore : AbstractSubSystem, IConfigurationStore, ISubSystem
  • public DefaultConfigurationStore()
  • public void AddBootstrapComponentConfiguration(string key, IConfiguration config)
  • public void AddChildContainerConfiguration(string key, IConfiguration config)
  • public void AddComponentConfiguration(string key, IConfiguration config)
  • public void AddFacilityConfiguration(string key, IConfiguration config)
  • public IConfiguration GetBootstrapComponentConfiguration(string key)
  • public IConfiguration[] GetBootstrapComponents()
  • public IConfiguration GetChildContainerConfiguration(string key)
  • public IConfiguration GetComponentConfiguration(string key)
  • public IConfiguration[] GetComponents()
  • public IConfiguration[] GetConfigurationForChildContainers()
  • public IConfiguration[] GetFacilities()
  • public IConfiguration GetFacilityConfiguration(string key)
  • public IResource GetResource(string resourceUri, IResource resource)
• public class DefaultConfigurationStore : AbstractSubSystem, IConfigurationStore, ISubSystem
• public interface IConfigurationStore : ISubSystem

Castle.MicroKernel.SubSystems.Conversion

• public abstract class AbstractTypeConverter : ITypeConverter
  • public ITypeConverterContext Context { get; set; }
  • protected AbstractTypeConverter()
  • public virtual bool CanHandleType(Type type, IConfiguration configuration)
  • public abstract bool CanHandleType(Type type)
  • public abstract object PerformConversion(string value, Type targetType)
  • public abstract object PerformConversion(IConfiguration configuration, Type targetType)
• public class ArrayConverter : AbstractTypeConverter
  • public ArrayConverter()
• public class AttributeAwareConverter : AbstractTypeConverter
  • public AttributeAwareConverter()
• public class ComponentConverter : AbstractTypeConverter, IKernelDependentConverter
  • public ComponentConverter()
• public class ComponentModelConverter : AbstractTypeConverter
  • public ComponentModelConverter()
• public class ConverterException : ApplicationException
  • public ConverterException(string message)
  • public ConverterException(string message, Exception innerException)
  • public ConverterException(SerializationInfo info, StreamingContext context)
• public class ConvertibleAttribute : Attribute
  • public Type ConverterType { get; }
  • public ConvertibleAttribute()
  • public ConvertibleAttribute(Type converterType)
• public class DefaultComplexConverter : AbstractTypeConverter
  • public DefaultComplexConverter()
• public class DefaultConversionManager : AbstractSubSystem, IConversionManager, ITypeConverter, ISubSystem, ITypeConverterContext
  • public ITypeConverter Composition { get; }
  • public ITypeConverterContext Context { get; set; }
  • public ComponentModel CurrentModel { get; }
  • public DefaultConversionManager()
  • public void Add(ITypeConverter converter)
  • public bool CanHandleType(Type type)
  • public bool CanHandleType(Type type, IConfiguration configuration)
  • protected virtual void InitDefaultConverters()
  • public bool IsSupportedAndPrimitiveType(Type type)
  • public object PerformConversion(string value, Type targetType)
  • public object PerformConversion(IConfiguration configuration, Type targetType)
  • public void PopModel()
  • public void PushModel(ComponentModel model)
• public class DictionaryConverter : AbstractTypeConverter
  • public DictionaryConverter()
• public class EnumConverter : AbstractTypeConverter
  • public EnumConverter()
• public class GenericDictionaryConverter : AbstractTypeConverter
  • public GenericDictionaryConverter()
• public class GenericListConverter : AbstractTypeConverter
  • public GenericListConverter()
• public interface IConversionManager : ITypeConverter, ISubSystem
  • void Add(ITypeConverter converter)
  • bool IsSupportedAndPrimitiveType(Type type)
• public interface IGenericCollectionConverterHelper
  • object ConvertConfigurationToCollection(IConfiguration configuration)
• public interface IKernelDependentConverter
• public interface ITypeConverter
  • ITypeConverterContext Context { get; set; }
  • bool CanHandleType(Type type)
  • bool CanHandleType(Type type, IConfiguration configuration)
  • object PerformConversion(string value, Type targetType)
  • object PerformConversion(IConfiguration configuration, Type targetType)
• public interface ITypeConverterContext
  • ITypeConverter Composition { get; }
  • ComponentModel CurrentModel { get; }
  • IKernel Kernel { get; }
  • void PopModel()
  • void PushModel(ComponentModel model)
• public class ListConverter : AbstractTypeConverter
  • public ListConverter()
• public class PrimitiveConverter : AbstractTypeConverter
  • public PrimitiveConverter()
• public class TimeSpanConverter : AbstractTypeConverter
  • public TimeSpanConverter()
• public class TypeNameConverter : AbstractTypeConverter
  • public TypeNameConverter()
• 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 BinaryTreeComponentName
  • public int Count { get; }
  • public IHandler[] Handlers { get; }
  • public BinaryTreeComponentName()
  • public void Add(ComponentName name, IHandler handler)
  • public bool Contains(ComponentName name)
  • public IHandler GetHandler(ComponentName name)
  • public IHandler[] GetHandlers(ComponentName name)
  • public void Remove(ComponentName name)
• public class ComponentName : ISerializable
  • protected bool allProperties
  • protected string internalliteralProperties
  • protected HybridDictionary internalproperties
  • protected string internalService
  • public string this[string key] { get; }
  • public string LiteralProperties { get; }
  • public string Service { get; }
  • public ComponentName(string name)
  • public ComponentName(string service, string properties)
  • public ComponentName(SerializationInfo info, StreamingContext context)
  • public void GetObjectData(SerializationInfo info, StreamingContext context)
  • protected virtual void Setup(string name)
  • protected virtual void SetupProperties(string properties)
  • protected virtual void SetupProperties(IDictionary properties)
  • protected virtual void SetupService(string service)
• public class DefaultNamingSubSystem : AbstractSubSystem, INamingSubSystem, ISubSystem
  • protected IDictionary<string, IHandler> key2Handler
  • protected IDictionary<Type, IHandler> service2Handler
  • public virtual int ComponentCount { get; }
  • public DefaultNamingSubSystem()
  • public void AddHandlerSelector(IHandlerSelector selector)
  • public virtual bool Contains(string key)
  • public virtual bool Contains(Type service)
  • public virtual IHandler[] GetAssignableHandlers(Type service)
  • public virtual IHandler GetHandler(string key)
  • public virtual IHandler GetHandler(Type service)
  • public virtual IHandler GetHandler(string key, Type service)
  • public virtual IHandler[] GetHandlers(string query)
  • public virtual IHandler[] GetHandlers(Type service)
  • public virtual IHandler[] GetHandlers()
  • public IDictionary<string, IHandler> GetKey2Handler()
  • protected virtual IHandler GetSelectorsOpinion(string key, Type type)
  • public IDictionary<Type, IHandler> GetService2Handler()
  • public virtual void Register(string key, IHandler handler)
  • public virtual void UnRegister(string key)
  • public virtual void UnRegister(Type service)
• public class KeySearchNamingSubSystem : DefaultNamingSubSystem
  • protected readonly Predicate<string> keyPredicate
  • protected readonly IDictionary service2Keys
  • public KeySearchNamingSubSystem()
  • public KeySearchNamingSubSystem(Predicate<string> keyPredicate)
• public class NamingPartsSubSystem : DefaultNamingSubSystem
  • public NamingPartsSubSystem()
• public class DefaultNamingSubSystem : AbstractSubSystem, INamingSubSystem, ISubSystem
• public interface INamingSubSystem : ISubSystem

Castle.MicroKernel.SubSystems.Resource

• public class DefaultResourceSubSystem : AbstractSubSystem, IResourceSubSystem, ISubSystem
  • public DefaultResourceSubSystem()
  • public IResource CreateResource(string resource)
  • public IResource CreateResource(string resource, string basePath)
  • public IResource CreateResource(CustomUri uri)
  • public IResource CreateResource(CustomUri uri, string basePath)
  • protected virtual void InitDefaultResourceFactories()
  • public void RegisterResourceFactory(IResourceFactory resourceFactory)
• public interface IResourceSubSystem : ISubSystem
  • IResource CreateResource(CustomUri uri)
  • IResource CreateResource(CustomUri uri, string basePath)
  • IResource CreateResource(string resource)
  • IResource CreateResource(string resource, string basePath)
  • void RegisterResourceFactory(IResourceFactory resourceFactory)
• public class DefaultResourceSubSystem : AbstractSubSystem, IResourceSubSystem, ISubSystem
• public interface IResourceSubSystem : ISubSystem

Castle.MicroKernel.Util

• public static class GenericTypeNameProvider
  • public static string AppendGenericTypeName(IHandler handler, Type genericService, string key)
  • public static string StripGenericTypeName(string key)
• public class ReferenceComparer : IComparer
  • public ReferenceComparer()
  • public int Compare(object x, object y)
• public class ReferenceEqualityComparer : IEqualityComparer, IEqualityComparer<object>
  • public ReferenceEqualityComparer()
  • public bool Equals(object x, object y)
  • public int GetHashCode(object obj)
• public abstract class ReferenceExpressionUtil
  • protected ReferenceExpressionUtil()
  • public static string ExtractComponentKey(string value)
  • public static bool IsReference(string value)
• 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 DefaultXmlProcessorNodeList : IXmlProcessorNodeList
  • public DefaultXmlProcessorNodeList(IList<XmlNode> nodes)
  • public DefaultXmlProcessorNodeList(ArrayList nodes)
  • protected IList<XmlNode> CloneNodeList(XmlNodeList nodeList)
  • protected ArrayList CloneNodeList(XmlNodeList nodeList)
• 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)