Castle.Windsor

The nodes that this node depends on

The node has not been visited yet

This node is in the process of being visited

This now was visited

Represents a collection of objects which are guaranteed to be unique and holds a color for them

Holds a timestamp (integer) for a given item

Abstract representation of a vertex.

Marker class used to denote components that have late bound type That is the actual type is not known exactly at the time when is created. Those are for example components instantiated via abstract factory.

If the extended type is a Foo[] or IEnumerable{Foo} which is assignable from Foo[] this method will return typeof(Foo) otherwise null.

Simple type for thread safe adding/reading to/from keyed store. The difference between this and built in concurrent dictionary is that in this case adding is happening under a lock so never more than one thread will be adding at a time.

Returns all values and clears the dictionary

Performs string comparison using

0 == false, 1 = =true

Signals (sets) the flag.

true if the current thread signaled the flag, false if some other thread signaled the flag before.

Checkis if given is a primitive type or collection of primitive types. Value types, are considered primitive and can not be registered as components in Windsor

Checkis if given is a primitive type. Value types and are considered primitive and can not be registered as components in Windsor

Calls and if a generic constraint is violated returns null instead of throwing .

Indicates that the target components wants instance lifetime and reuse scope to be bound to another component further up the object graph. Good scenario for this would be unit of work bound to a presenter in a two tier MVP application. The attribute must point to a type having default accessible constructor and public method matching signature of Func<IHandler[], IHandler> delegate.

Initializes a new instance of the class.

type having default accessible constructor and public method matching signature of Func<IHandler[], IHandler> delegate. The method will be used to pick of the component current instance should be bound to.

This attribute is useful only when you want to register all components on an assembly as a batch process. By doing so, the batch register will look for this attribute to distinguish components from other classes.

Associates a custom activator with a component

Initializes a new instance of the class.

Type of the component activator.

Gets the type of the component activator.

The type of the component activator.

Represents the collection of information and meta information collected about a component.

Dependencies the kernel must resolve

Interceptors associated

External parameters

All potential properties that can be setted by the kernel

Constructs a ComponentModel

Gets or sets the configuration.

The configuration.

Gets the constructors candidates.

The constructors.

Gets or sets the custom component activator.

The custom component activator.

Gets the custom dependencies.

The custom dependencies.

Gets or sets the custom lifestyle.

The custom lifestyle.

Dependencies are kept within constructors and properties. Others dependencies must be registered here, so the kernel (as a matter of fact the handler) can check them

Gets or sets the extended properties.

The extended properties.

Gets or sets the component implementation.

The implementation.

Gets or sets the strategy for inspecting public properties on the components

Gets the interceptors.

The interceptors.

Gets the lifecycle steps.

The lifecycle steps.

Gets or sets the lifestyle type.

The type of the lifestyle.

Sets or returns the component key

Gets the parameter collection.

The parameters.

Gets the properties set.

The properties.

Gets or sets a value indicating whether the component requires generic arguments.

true if generic arguments are required; otherwise, false .

Adds constructor dependency to this

Adds property dependency to this

Add service to be exposed by this

Requires the selected property dependencies.

The property selector.

Requires the property dependencies of type .

The dependency type.

Gets the default name for component implemented by which will be used in case when user does not provide one explicitly.

Specifies the proxying behavior for a component.

Gets or sets a value indicating whether the generated interface proxy should inherit from .

Gets or sets the additional interfaces used during proxy generation.

Represents a constructor of the component that the container can use to initialize it properly.

Initializes a new instance of the class.

The constructor info. The dependencies.

Gets the ConstructorInfo (from reflection).

The constructor.

Gets the dependencies this constructor candidate exposes.

The dependencies.

Collection of

Indicates that the target components wants a custom lifestyle.

Initializes a new instance of the class.

The custom lifestyle type.

Represents a dependency (other component or a fixed value available through external configuration).

Initializes a new instance of the class.

The dependency key. Type of the target. if set to true [is optional].

The default value of this dependency. Note that null is a valid default value. Use to determine whether default value was provided.

Gets or sets the dependency key.

The dependency key.

Specifies whether dependency has a default value (). Note that null is a valid default value.

Gets or sets whether this dependency is optional.

true if this dependency is optional; otherwise, false .

Gets the service type of the dependency. This is the same type as or if is by ref, then it's the element type of the reference. (in other words if dependency is out IFoo foo this will be IFoo, while will be &IFoo);

Gets the type of the target.

The type of the target.

Returns a that represents the current .

A that represents the current .

Collection of .

Marks as constructor to be skipped and not be selected by the IoC container during new component activation

Marks as property to be skipped and not be wired by the IoC container

Represents a concern that will be applied to a component instance during commission phase (right after component instance is activated).

Implementors should act on the instance in response to a commission phase.

The model. The component.

Represents a concern that will be applied to a component instance during decommission phase (right before component instance is destroyed).

Implementors should act on the instance in response to a decommission phase.

The model. The component.

Lifecycle interface. If implemented by a component, the method Initialize will be invoked by the container before making the component available to the external world.

Implementors should perform any initialization logic.

Used to declare that a component wants interceptors acting on it. Out of the box recognized only if applied on component's implementation class.

Constructs the InterceptorAttribute pointing to a key to a interceptor

Constructs the InterceptorAttribute pointing to a service

Represents an reference to a Interceptor component.

Initializes a new instance of the class.

The component key.

Initializes a new instance of the class.

Type of the interceptor to use. This will reference the default component (ie. one with no explicitly assigned name) implemented by given type.

Gets an for the component key.

The component key. The

Gets an for the service.

The service. The

Gets an for the service.

The service type. The

Collection of

Gets a value indicating whether this instance has interceptors.

true if this instance has interceptors; otherwise, false.

Adds the specified interceptor as the first.

The interceptor.

Adds the interceptor to the end of the interceptors list if it does not exist already.

The interceptor reference.

Adds the specified interceptor as the last.

The interceptor.

Inserts the specified interceptor at the specified index.

The index. The interceptor.

Returns an enumerator that can iterate through a collection.

An that can be used to iterate through the collection.

Adds the specified item.

The interceptor.

Interceptors might implement this to receive the ComponentModel on behalf of the component where the interceptor is acting.

Only called for components that belongs to a pool when the component comes back to the pool.

Implementors should perform any initialization/clean up.

Interface for components that wish to be started and stopped by the container

Starts this instance.

Stops this instance.

Represents a collection of ordered lifecycle concerns.

Returns all concerns for the commission phase

Returns all concerns for the decommission phase

Gets a value indicating whether this instance has commission steps.

true if this instance has commission steps; otherwise, false.

Gets a value indicating whether this instance has decommission steps.

true if this instance has decommission steps; otherwise, false.

Base for Attributes that want to express lifestyle chosen by the component.

Initializes a new instance of the class.

The type.

Gets or sets the lifestyle.

The lifestyle.

Enumeration used to mark the component's lifestyle.

No lifestyle specified.

Singleton components are instantiated once, and shared between all clients.

Thread components have a unique instance per thread.

Transient components are created on demand.

Optimization of transient components that keeps instance in a pool instead of always creating them.

Any other logic to create/release components.

Instances are reused within the scope provided.

Instance lifetime and reuse scope is bound to another component further up the object graph. Good scenario for this would be unit of work bound to a presenter in a two tier MVP application. When specified in xml a scopeRootBinderType attribute must be specified pointing to a type having default accessible constructor and public method matching signature of Func<IHandler[], IHandler> delegate.

Represents meta information associated with a method (not yet defined)

Initializes a new instance of the class.

The config node.

Gets the config node.

The config node.

Collection of

Gets the method info2 model.

The method info2 model.

Represents a parameter. Usually the parameter comes from the external world, ie, an external configuration.

Initializes a new instance of the class.

The name. The value.

Initializes a new instance of the class.

The name. The value.

Gets the config value.

The config value.

Gets the name.

The name.

Gets the value.

The value.

Collection of

Gets the count.

The count.

Gets the with the specified key.

Adds the specified name.

The name. The value.

Adds the specified name.

The name. The config node.

Adds the specified key.

Not implemented The key. The value.

Returns an enumerator that can iterate through a collection.

An that can be used to iterate through the collection.

Indicates that the target components wants a per thread lifestyle.

Initializes a new instance of the class.

Indicates that the target components wants a pooled lifestyle.

Initializes a new instance of the class using the default initial pool size (5) and the max pool size (15).

Initializes a new instance of the class.

Initial size of the pool. Max pool size.

Gets the initial size of the pool.

The initial size of the pool.

Gets the maximum pool size.

The size of the max pool.

Specifies rules for designating settable properties on a component as dependencies, and controlling whether they are requred or not. This is a shortcut for most common scenarios. More advanced/custom scenarios can be defined dynamically in the registration API.

Takes no action. By default that means all settable properties will be exposed as optional dependencies.

Makes all property dependencies required.

Makes all property dependencies defined at a base class/interfaces level required.

Makes all properties ignored.

Ignores all properties defined at a base class/interface level.

This option is particularily useful in scenarios like UI controls which in .NET UI frameworks tend to have byzantine inheritance hierarchies.

Represents a property and the respective dependency.

TODO: remove this class and instead create PropertyDependencyModel like we do for constructors

Initializes a new instance of the class.

The property info. The dependency.

Gets the dependency.

The dependency.

Gets the property.

The property.

Collection of

Finds a PropertySet the by PropertyInfo.

The info.

Indicates that the target components wants a scoped lifestyle.

Initializes a new instance of the class.

Indicates that the target components wants a singleton lifestyle.

Initializes a new instance of the class.

Indicates that the target components wants a transient lifestyle.

Initializes a new instance of the class.

This method changes behavior of the facility. Deferred mode should be used when you have single call to and register all your components there. Enabling this mode will optimize the behavior of the facility so that it will wait 'till the end of installation and only after all s were ran it will instantiate and start all the startable components. An exception will be thrown if a startable component can't be instantiated and started. This will help you fail fast and diagnose issues quickly. If you don't want the exception to be thrown and you prefer the component to fail silently, use method instead.

It is recommended to use this method over method.

Startable components will be started when method is invoked. This is particularily usedul when you need to perform some extra initialization outside of container before starting the Startable components.

This method changes behavior of the facility. Deferred mode should be used when you have single call to and register all your components there. Enabling this mode will optimize the behavior of the facility so that it will wait 'till the end of installation and only after all s were ran it will instantiate and start all the startable components. No exception will be thrown if a startable component can't be instantiated and started. If you'd rather fail fast and diagnose issues quickly, use method instead.

It is recommended to use method over this method. Don't check the waiting list while this flag is set as this could result in duplicate singletons.

Request the component instance

Assigns the start method for the startable.

The start method. Be sure that you first added the to the kernel, before registering this component.

Assigns the start method for the startable.

Method to use. something like: StartUsingMethod(s => s.Start) Be sure that you first added the to the kernel, before registering this component.

Assigns the stop method for the startable.

The stop method. Be sure that you first added the to the kernel, before registering this component.

Assigns the stop method for the startable.

Method to use. something like: StartUsingMethod(s => s.Start) Be sure that you first added the to the kernel, before registering this component. If set to true, all methods with names like 'GetSomething' will try to resolve by name component 'something'. Defaults to true. If set to true, will fallback to resolving by type, if can not find component with specified name. This property is here for backward compatibility. It is recommended not to use it. Defaults to false.

If set to true, will fallback to resolving by type, if can not find component with specified name. This property is here for backward compatibility. It is recommended not to use it.

If set to true, all methods with names like 'GetSomething' will try to resolve by name component 'something'.

Builds for given call. By default if is a collection returns factory calling on collection's item type, otherwise standard .

Selects arguments to be passed to resolution pipeline. By default passes all given keyed by names of their corresponding parameters.

Selects name of the component to resolve. If Name is GetFoo returns "Foo", otherwise null.

Selects type of the component to resolve. Uses return type.

Specifies default configuration for a typed factory. All Selector* properties are mutually exclusive, that is you're only meant to set one.

Specifies component to use as selector for given factory. This works like any named service override.

Specifies component to use as selector for given factory. This works like any typed service override.

Specifies type of the selector to use for given factory. The type will be instantiated using default constructor. It must implement

Legacy class from old impl. of the facility. Do not use it.

Legacy interceptor for old impl. of the facility.

Selects one or both of component name and type, for given method called on given typed factory type. When component should be requested by type only, componentName should be null. When component should be requested by name only, componentType should be null.

Represents a single component to be resolved via Typed Factory

Resolves the component(s) from given kernel.

Resolved component(s).

Provides automatically generated factories on top of interfaces or delegates that you can use to pull components out of the container without ever referencing it explicitly.

Marks the component as typed factory.

Only interfaces and delegates are legal to use as typed factories. Methods with out parameters are not allowed. When registering component as typed factory no implementation should be provided (in case there is any it will be ignored). Typed factories rely on set internally, so users should not set interceptor selectors explicitly; otherwise the factory will not function correctly.

Marks the component as typed factory.

Name of the component to be used for this factory Only interfaces and delegates are legal to use as typed factories. Methods with out parameters are not allowed. When registering component as typed factory no implementation should be provided (in case there is any it will be ignored). Typed factories rely on set internally, so users should not set interceptor selectors explicitly; otherwise the factory will not function correctly.

Marks the component as typed factory.

Type of the component to be used for this factory Only interfaces and delegates are legal to use as typed factories. Methods with out parameters are not allowed. When registering component as typed factory no implementation should be provided (in case there is any it will be ignored). Typed factories rely on set internally, so users should not set interceptor selectors explicitly; otherwise the factory will not function correctly.

Marks the component as typed factory.

The instance to be used for this factory Only interfaces and delegates are legal to use as typed factories. Methods with out parameters are not allowed. When registering component as typed factory no implementation should be provided (in case there is any it will be ignored). Typed factories rely on set internally, so users should not set interceptor selectors explicitly; otherwise the factory will not function correctly.

Marks the component as typed factory.

Represents a collection of named and typed arguments used for dependencies resolved via See: https://github.com/castleproject/Windsor/blob/master/docs/arguments.md

Initializes a new instance of the class that is empty.

Initializes a new instance of the class that contains elements copied from the specified .

Adds a collection of named and/or typed arguments.

Adds a named argument.

Adds a collection of named arguments, implements this interface.

Adds a collection of named arguments from public properties of a standard or anonymous type.

Adds a typed argument.

Adds a collection of typed arguments.

Initializes a new instance of the class and adds a collection of named arguments, implements this interface.

Initializes a new instance of the class and adds a collection of named arguments from public properties of a standard or anonymous type.

Initializes a new instance of the class and adds a collection of typed arguments, implements this interface.

Initializes a new instance of the class and adds a collection of typed arguments.

If true requires release by . If false , the object has a well defined, detectable end of life (web-request end, disposal of the container etc), and will be released externally.

Exception throw when a circular dependency is detected

Initializes a new instance of the class.

The message.

Initializes a new instance of the class.

The message. The inner exception.

Initializes a new instance of the class.

The that holds the serialized object data about the exception being thrown. The that contains contextual information about the source or destination. The parameter is . The class name is or is zero (0).

Abstract implementation of . The implementors must only override the InternalCreate and InternalDestroy methods in order to perform their creation and destruction logic.

Constructs an AbstractComponentActivator

Exception thrown whe a component could not be activated. THis should come from the component activator.

Standard implementation of . Handles the selection of the best constructor, fills the writable properties the component exposes, run the commission and decommission lifecycles, etc.

Custom implementors can just override the CreateInstance method. Please note however that the activator is responsible for the proxy creation when needed.

Initializes a new instance of the class.

Implemented by which don't necessarily need dependencies from the container to activate new instances of the component.

Should return true if the activator can provide dependencies for the .

Should return true if the activated instances of the are managed externally to the container. That means container will not try to track the objects in .

Exception thrown when component has no resolvable constructor that can be used to create an instance.

Exception threw when a request for a component cannot be satisfied because the component does not exist in the container

Initializes a new instance of the class.

The name. Exception message.

Initializes a new instance of the class.

The service. Exception message.

Initializes a new instance of the class.

The service.

Initializes a new instance of the class.

The object that holds the serialized object data. The contextual information about the source or destination.

Reference to component obtained from the container.

Creates a new instance of referencing default component implemented by

Creates a new instance of referencing component

Exception threw when there is a problem registering a component

Initializes a new instance of the class.

The message.

Initializes a new instance of the class.

The object that holds the serialized object data. The contextual information about the source or destination.

Exception thrown when resolution process for a component was unsuccessful at some point for whatever reason.

Used during a component request, passed along to the whole process. This allow some data to be passed along the process, which is used to detected cycled dependency graphs and now it's also being used to provide arguments to components.

The list of handlers that are used to resolve the component. We track that in order to try to avoid attempts to resolve a service with itself.

Initializes a new instance of the class.

The type to extract generic arguments. The parent context. When set to true will clone .

Initializes a new instance of the class.

The handler. The release policy. The type to extract generic arguments. The additional arguments. The conversion manager. Parent context

Initializes a new instance of the class.

Method used by handlers to test whether they are being resolved in the context.

This method is provided as part of double dispatch mechanism for use by handlers. Outside of handlers, call instead.

Creates a new, empty instance.

A new CreationContext should be created every time, as the contexts keeps some state related to dependency resolution.

Default implementation of . This implementation is complete and also support a kernel hierarchy (sub containers).

List of sub containers.

List of registered.

Map of subsystems registered.

The parent kernel, if exists.

Constructs a DefaultKernel with no component proxy support.

Constructs a DefaultKernel with the specified implementation of and

Constructs a DefaultKernel with the specified implementation of

Graph of components and interactions.

Starts the process of component disposal.

Return handlers for components that implements the specified service. The check is made using IsAssignableFrom

Returns the facilities registered on the kernel.

Return handlers for components that implements the specified service.

Returns all handlers for all components

Handler which is a sub dependency resolver for a component

Registers the components with the . The instances of are produced by fluent registration API. Most common entry points are method to register a single type or (recommended in most cases) . Let the Intellisense drive you through the fluent API past those entry points.

kernel.Register(Component.For<IService>().ImplementedBy<DefaultService>().LifestyleTransient());

kernel.Register(Classes.FromThisAssembly().BasedOn<IService>().WithServiceDefaultInterfaces().Configure(c => c.LifestyleTransient()));

The component registrations created by , or different entry method to the fluent API. The kernel.

Releases a component instance. This allows the kernel to execute the proper decommission lifecycles on the component instance.

Creates an implementation of based on and invokes to initialize the newly created manager.

It is the responsibility of the kernel to ensure that handler is only ever disposed once.

Returns a component instance by the key

Returns the component instance by the service type using dynamic arguments

Returns the component instance by the component key

Returns a component instance by the key

Component's key Service type The Component instance

Returns a component instance by the key

Service type Component's key The Component instance

Returns the component instance by the service type

Returns the component instance by the service type using dynamic arguments

Returns all the valid component instances by the service type

The service type

Returns all the valid component instances by the service type

The service type Arguments to resolve the services

Returns component instances that implement TService

Returns a component instance by the key

Base class for facilities.

Gets the facility configuration.

The representing the facility configuration.

Gets the where the facility is registered.

The .

The custom initialization for the Facility.

It must be overridden.

Performs the tasks associated with freeing, releasing, or resetting the facility resources.

It can be overriden.

Initializes the facility. First it performs the initialization common for all facilities, setting the and the . After it, the Init method is invoked and the custom initilization is perfomed.

Terminates the Facility, invokes the method and sets the Kernel to a null reference.

Base exception to be used by facilities.

Possible states for a IHandler instance

The component can be requested

The component can not be requested as it still depending on a external dependency not yet available

Implements the basis of

Dictionary of key (string) to

Constructs and initializes the handler

Gets the component model.

Gets the handler state.

Should be implemented by derived classes: disposes the component instance (or recycle it)

true if destroyed.

Returns an instance of the component this handler is responsible for

when false , handler can not create valid instance and return null instead

Saves the kernel instance, subscribes to event, creates the lifestyle manager instance and computes the handler state.

disposes the component instance (or recycle it).

Returns an instance of the component this handler is responsible for

Invoked by in order to check if a dependency can be satisfied. If not, the handler is set to a 'waiting dependency' state.

This method registers the dependencies within the correct collection or dictionary and changes the handler state to

Invoked by the kernel when one of registered dependencies were satisfied by new components registered.

Handler for the event

Invoked when the container receives a parent container reference.

This method implementation checks whether the parent container is able to supply the dependencies for this handler.

Clone some of the parent componentmodel properties to the generic subhandler.

The following properties are copied: The The the subhandler

Summary description for DefaultHandler.

Lifestyle manager instance

Initializes a new instance of the class.

Lifestyle manager instance

disposes the component instance (or recycle it)

true if destroyed

Returns an instance of the component this handler is responsible for

Thrown when can't create proper closed version of itself due to violation of generic constraints.

Initializes a new instance of the class.

The message.

Initializes a new instance of the class.

The message.

Initializes a new instance of the class.

The object that holds the serialized object data. The contextual information about the source or destination.

Summary description for HandlerException.

Initializes a new instance of the class.

The message.

Initializes a new instance of the class.

The message.

Initializes a new instance of the class.

The object that holds the serialized object data. The contextual information about the source or destination.

Inspects missings dependencies in the container. Default implementation is used to construct helpful message for exceptions and debugger views, but other implementations are also possible if needed.

Might be implemented by a handler so it can expose access to dependency information which is used to construct meaningful error messages

Informs the about missing dependencies. Implementers should ignore the call if no dependencies are missing and call back the inspector with the information required otherwise

Initializes a new instance of the class.

The parent handler. The child resolver. Release policy of the parent container.

Implements the instance creation logic. The default implementation should rely on an ordinary call to Activator.CreateInstance().

This interface is provided in order to allow custom components to be created using a different logic, such as using a specific factory or builder. The constructor for implementation has the following signature:


                ComponentModel model, IKernel kernel, 
                ComponentInstanceDelegate onCreation, 
                ComponentInstanceDelegate onDestruction

The Activator should raise the events onCreation and onDestruction in order to correctly implement the contract. Usually the best way of creating a custom activator is by extending the existing ones.

Should return a new component instance.

Should perform all necessary work to dispose the instance and/or any resource related to it.

Implementors must construct a populated instance of ComponentModel by inspecting the component and|or the configuration.

"To give or supply in common with others; give to a common fund or for a common purpose". The contributor should inspect the component, or even the configuration associated with the component, to add or change information in the model that can be used later.

Constructs a new ComponentModel by invoking the registered contributors.

Removes the specified contributor

Implementors should use a strategy to obtain valid references to properties and/or services requested in the dependency model.

Registers a sub resolver instance

The subresolver instance

This method is called with a delegate for firing the IKernelEvents.DependencyResolving event.

kernel The delegate used to fire the event

Unregisters a sub resolver instance previously registered

The subresolver instance

Unit of extension. A facility should use the extension points offered by the kernel to augment its functionality.

Contract for the IHandler, which manages an component state and coordinates its creation and destruction (dispatching to activators, lifestyle managers)

Gets the model of the component being managed by this handler.

Gets the state of the handler

Initializes the handler with a reference to the kernel.

Tests whether the handler is already being resolved in given context.

Implementors should dispose the component instance

true if destroyed.

Implementors should return a valid instance for the component the handler is responsible. It should throw an exception in the case the component can't be created for some reason

Returns true if this handler supports

Implementors should return a valid instance for the component the handler is responsible. It should return null in the case the component can't be created for some reason. No exception should be thrown.

Extension point to allow the developer to use his implementation of

Implementors of this interface allow to extend the way the container perform component resolution based on some application specific business logic.

This is the sibling interface to . This is dealing strictly with root components, while the is dealing with dependent components.

Whatever the selector has an opinion about resolving a component with the specified service and key.

The service key - can be null The service interface that we want to resolve

Select the appropriate handler from the list of defined handlers. The returned handler should be a member from the array.

The service key - can be null The service interface that we want to resolve The defined handlers The selected handler, or null

Implementation of this interface allows for extension of the way the container looks up multiple handlers. It provides the necessary hook to allow for business logic to prioritize, filter, and sort handlers when resolving multiple handlers.

Whatever the selector has an opinion about resolving a component with the specified service and key.

The service interface that we want to resolve

Select the appropriate handlers (if any) from the list of defined handlers, returning them in the order they should be executed. The returned handlers should members from the array.

The service interface that we want to resolve The defined handlers The selected handlers, or an empty array, or null

The IKernel interface exposes all the functionality the MicroKernel implements.

It allows you to register components and request them by their name or the services they expose. It also allow you to register facilities and subsystem, thus augmenting the functionality exposed by the kernel alone to fit your needs.

Returns the implementation of

Gets or sets the implementation of

Graph of components and interactions.

Returns the implementation of

Returns the parent kernel

Gets or sets the implementation of allowing different strategies for proxy creation.

Gets or sets the implementation for

Returns the implementation for

Support for kernel hierarchy

Adds a to the kernel.

Creates and adds an facility to the kernel.

The facility type.

Creates and adds an facility to the kernel.

The facility type. The callback for creation.

Register a new component resolver that can take part in the decision making about which handler(s) to resolve and in which order

Adds (or replaces) an

Return handlers for components that implements the specified service. The check is made using IsAssignableFrom

Returns the facilities registered on the kernel.

Returns the for the specified component name.

Returns the for the specified service.

Returns the for the all components.

Handlers which implement sub dependency resolvers

Return handlers for components that implements the specified service.

Returns an implementation of for the specified name.

Returns true if a component with given was registered, otherwise false.

Returns true if the specified service was registered


                kernel.Register(Component.For<IService>().ImplementedBy<DefaultService>().LifestyleTransient());


                kernel.Register(Classes.FromThisAssembly().BasedOn<IService>().WithServiceDefaultInterfaces().Configure(c => c.LifestyleTransient()));

The component registrations created by , or different entry method to the fluent API. The kernel.

Releases a component instance. This allows the kernel to execute the proper decommission lifecycles on the component instance.

Remove child kernel

Returns the component instance by the service type

Returns the component instance by the service type using dynamic arguments

Returns a component instance by the key

Returns the component instance by the service type using dynamic arguments

Returns the component instance by the component key

Returns a component instance by the key

Component's key Service type The Component instance

Returns a component instance by the key

Service type Component's key The Component instance

Returns a component instance by the key

Returns all the valid component instances by the service type

The service type

Returns all the valid component instances by the service type

The service type Arguments to resolve the services

Returns component instances that implement TService

Represents a delegate which holds basic information about a component.

Key which identifies the component handler that holds this component and is capable of creating an instance of it.

Represents a delegate which holds basic information about a component and its instance.

Component meta information Component instance

Represents a delegate which holds the information about the component

Represents a delegate which holds the information about a service.

Represents a delegate which holds a handler

handler that holds a component and is capable of creating an instance of it.

Represents a delegate which holds dependency resolving information.

Summary description for IKernelEvents.

Event fired when a new component is registered on the kernel.

Event fired after the ComponentModel is created. Allows customizations that may affect the handler.

Event fired when the kernel was added as child of another kernel.

Event fired when the kernel was removed from being a child of another kernel.

Event fired before the component is created.

Event fired when a component instance destroyed.

Event fired when a new handler is registered (it might be in a valid or waiting dependency state)

Event fired when a dependency is being resolved, it allows the dependency to be changed, but the client ComponentModel must not be changed.

Event fired when registration / installation process is completed. That is when container is about to exit method. This event is raised once regardless of how many components were registered. If the is called by the event is raised when that method exits.

Event fired when a collection is being resolved (via or another overload) and the collection is empty. Implementors would usually log that fact or potentially throw an exception (especially in development).

Extended contract of kernel, used internally.

Internal logger used by the container (not just implementation itself but also other classes too) to log information about what's happening in the container.

Adds a custom made . Used by facilities.

Constructs an implementation of for the given

Returns a component instance by the key

The ILifestyleManager implements a strategy for a given lifestyle, like singleton, per-thread and transient.

The responsibility of ILifestyleManager is only the management of lifestyle. It should rely on to obtain a new component instance

Initializes the ILifestyleManager with the

Implementors should release the component instance based on the lifestyle semantic, for example, singleton components should not be released on a call for release, instead they should release them when disposed is invoked.

Implementors should return the component instance based on the lifestyle semantic. Also the instance should be set to , should be also set if needed and if a new instance was created it should be passed on to of .

Represents a reference to an existing object.

Defines the contract used by the kernel to obtain proxies for components. The implementor must return a proxied instance that dispatch the invocation to the registered interceptors in the model

Add the selector to the list of selectors that can affect interceptor's decisions in the container.

Implementors must create a proxy based on the information exposed by ComponentModel

The kernel instance The component model The component instance to be proxy (only required in some cases) array of parameters to the constructor (if any) The creation context proxy instance

Implementor should check the component model and determine if the caller must pass on the component instance to the proxy

The kernel instance The component model true if an instance must be passed to

Determines whatever we need to create a proxy for this model

Represents obtained just in time object.

If the reference introduces dependency on a component, should return for that dependency, otherwise null.

Resolves object referenced by this reference, optionally using provided . If object is resolved from the kernel, the should be used to guard against against cyclic dependencies.

Policy managing lifetime of components, and in particular their release process.

Creates nested policy for scoped object tracking.

Returns true if is being tracked by this release policy, false otherwise.

Releases if it's being tracked by this release policy, invoking its s and stops tracking it so that it can be claimed by the Garbage Collector.

Asks the policy to track given object. The object will be released when a call to is made.

Thrown when does NOT have its flag set.

Implementors should use a strategy to obtain valid references to properties and/or services requested in the dependency model.

Returns true if the resolver is able to satisfy this dependency.

Creation context, which is a resolver itself Parent resolver - normally the IHandler implementation Model of the component that is requesting the dependency The dependency model true if the dependency can be satisfied

Should return an instance of a service or property values as specified by the dependency model instance. It is also the responsibility of to throw an exception in the case a non-optional dependency could not be resolved.

A subsystem is used by the MicroKernel to deal with a specific concern.

Initializes the subsystem

Should perform the termination of the subsystem instance.

Exception threw by Kernel operations that failed for some reason.

Initializes a new instance of the class.

The message.

Initializes a new instance of the class.

The message. The inner exception.

Initializes a new instance of the class.

The object that holds the serialized object data. The contextual information about the source or destination.

Summary description for DisposalConcern.

Summary description for InitializationConcern.

Lifetime concern that works for components that don't have their actual type determined upfront

Summary description for SupportInitializeConcern.

Base implementation of

Invoked when the container gets disposed. The container will not call it multiple times in multithreaded environments. However it may be called at the same time when some out of band release mechanism is in progress. Resolving those potential issues is the task of implementors

Begins a scope.

The . Returns an to be used in a using block.

Begins a scope.

The . Returns an to be used in a using block.

Begins a scope if not executing inside one.

The . Returns an to be used in a using block.

Begins a scope if not executing inside one.

The . Returns an to be used in a using block.

Manages a pool of objects.

Pool implementation contract.

Implementors should release the instance or put it on the pool

Provides explicit lifetime scoping within logical path of execution. Used for types with .

The scope is passed on to child threads, including ThreadPool threads. The capability is limited to a single AppDomain and should be used cautiously as calls to may occur while the child thread is still executing, which in turn may lead to subtle threading bugs. This class is not thread safe like CallContextLifetimeScope.

Provides access to held in whatever is appropriate for given scope.

Implementors should also ensure proper initialization of when accessed for the first time and ensure a thread safe implementation is used when scope or cache access can cause threading issues if non thread safe cache is used.

Provides access to for currently resolved component.

Current creation context Thrown when scope cache could not be accessed.

Represents persistence mechanism for instances of components that are supposed to be reused within scope managing the cache.

Saves or retrieves a stored in the cache associated with the given .

Thrown when is null. Thrown when there is already a associated with given value in the cache. The interface gives no thread safety guarantees. When the scope can be accessed from multiple threads the implementor should ensure thread safety.

Delegate used by to request a new instance to be created (that would be the first instance in that scope, subsequently reused).

Callback which should be invoken by provided delegate right after isntance gets created and before it burden gets tracked. The purpose if this callback is to include scope in decisions regarding tracking of the instance by . Depending on the scope implementation it may or may not provide its own end of lifetime detection mechanism.

Only one instance is created first time an instance of the component is requested, and it is then reused for all subseque.

Transient components are never reused. Since their lifetime does not have any externally constrained end, they have to be manually released if resolved explicitly, to ensure proper decomission.

Summary description for DefaultComponentModelBuilder.

Initializes a new instance of the class.

The kernel.

Gets the contributors.

The contributors.

Constructs a new ComponentModel by invoking the registered contributors.

Removes the specified contributor

Initializes the default contributors.

Constructs the descriptor with name and value.

The attribute name. The attribute value.

Constructs the descriptor with name.

The component. The attribute name.

Builds the with value.

The attribute value. The

Adds the actions to ExtendedProperties.

Contribute to component model before standard run.

Contribute to component model after standard run.

Implementors must inspect the component for a given information or parameter.

Usually the implementation will look in the configuration property of the model or the service interface, or the implementation looking for something.

The kernel instance The component model

Contribute to component model after standard run.

Inspects the component configuration and the type looking for a definition of component activator type. The configuration preceeds whatever is defined in the component.

This inspector is not guarantee to always set up an component activator type. If nothing could be found it wont touch the model. In this case is up to the kernel to establish a default component activator for components.

Searches for the component activator in the configuration and, if unsuccessful look for the component activator attribute in the implementation type.

The kernel instance The model instance

Reads the attribute "componentActivatorType" associated with the component configuration and verifies it implements the interface.

If the type does not implement the proper interface

Check if the type expose one of the component activator attributes defined in Castle.Core namespace.

Validates that the provide type implements IComponentActivator

The custom component activator.

Inspects the component configuration and type looking for information that can influence the generation of a proxy for that component. We specifically look for additionalInterfaces and marshalByRefProxy on the component configuration or the attribute.

Searches for proxy behavior in the configuration and, if unsuccessful look for the attribute in the implementation type.

Returns a instance if the type uses the attribute. Otherwise returns null.

Reads the proxy behavior associated with the component configuration/type and applies it to the model.

If the conversion fails

Uses the ConfigurationStore registered in the kernel to obtain an associated with the component.

Queries the kernel's ConfigurationStore for a configuration associated with the component name.

Check for a node 'parameters' within the component configuration. For each child it, a ParameterModel is created and added to ComponentModel's Parameters collection

Inspect the configuration associated with the component and populates the parameter model collection accordingly

This implementation of collects all available constructors and populates them in the model as candidates. The Kernel will pick up one of the candidates according to a heuristic.

Only to hold internal constants and get rid of magic numbers and hardcode names.

Inspect the component for InterceptorAttribute and the configuration for the interceptors node

Inspects the type looking for interfaces that constitutes lifecycle interfaces, defined in the Castle.Model namespace.

Checks if the type implements and or interfaces.

Inspects the component configuration and the type looking for a definition of lifestyle type. The configuration preceeds whatever is defined in the component.

This inspector is not guarantee to always set up an lifestyle type. If nothing could be found it wont touch the model. In this case is up to the kernel to establish a default lifestyle for components.

Searches for the lifestyle in the configuration and, if unsuccessful look for the lifestyle attribute in the implementation type.

Reads the attribute "lifestyle" associated with the component configuration and tries to convert to enum type.

Check if the type expose one of the lifestyle attributes defined in Castle.Model namespace.

Base for inspectors that want configuration associated with methods. For each child a is created and added to ComponentModel's methods collection

Implementors should override the return the name of the node to be inspected. For example:

]]>

This implementation of collects all potential writable public properties exposed by the component implementation and populates the model with them. The Kernel might be able to set some of these properties when the component is requested.

Adds the properties as optional dependencies of this component.

Select the appropriate interceptors based on the application specific business logic

Determine whatever the specified has interceptors. The selector should only return true from this method if it has determined that is a model that it would likely add interceptors to.

The model Whatever this selector is likely to add interceptors to the specified model

Select the appropriate interceptor references. The interceptor references aren't necessarily registered in the model.Intereceptors

The model to select the interceptors for The interceptors selected by previous selectors in the pipeline or if this is the first interceptor in the pipeline. The interceptor for this model (in the current context) or a null reference If the selector is not interested in modifying the interceptors for this model, it should return and the next selector in line would be executed. If the selector wants no interceptors to be used it can either return null or empty array. However next interceptor in line is free to override this choice.

This is a placeholder implementation of .

The decision to supply no implementation for is supported by the fact that the MicroKernel should be a thin assembly with the minimal set of features, although extensible. Providing the support for this interface would obligate the user to import another assembly, even if the large majority of simple cases, no use use of interceptors will take place. If you want to use however, see the Windsor container.

Holds the keys used by the proxy factories.

Key used to supply custom proxy options.

Represents options to configure proxies.

Initializes a new instance of the class.

Gets the additional interfaces to proxy.

The interfaces.

Determines if the proxied component can change targets.

Determines if the interface proxied component should inherit from

Gets or sets the proxy hook.

Gets the mix ins to integrate.

The interfaces.

Determines if the proxied component uses a target.

Gets or sets the interceptor selector.

Adds the additional interfaces to proxy.

The interfaces.

Adds the additional mix ins to integrate.

The mix ins.

Adds the additional mix in to integrate.

The mix in.

Equals the specified obj.

The obj. true if equal.

Gets the hash code.

Helper support for proxy configuration.

Obtains the associated with the .

The component model. true if the options should be created if not present. The associated proxy options for the component model.

Describes how to register a group of related types.

Initializes a new instance of the BasedOnDescriptor.

Gets the service descriptor.

Allows a type to be registered multiple times.

Adds another type to be accepted as base.

The base type. The descriptor for the type.

Allows customized configurations of each matching type.

The configuration action.

Allows customized configurations of each matching component with implementation type that is assignable to .

The type assignable from. The configuration action.

Allows customized configurations of each matching component that satisfies supplied .

Condition to satisfy The configuration action, executed only for components for which evaluates to true .

Allows customized configurations of each matching component that satisfies supplied and alternative configuration for the rest of components.

Condition to satisfy The configuration action, executed only for components for which evaluates to true . The configuration action, executed only for components for which evaluates to false .

Assigns a conditional predication which must be satisfied.

The predicate to satisfy.

Assigns a conditional predication which must not be satisfied.

The predicate not to satisify.

Uses all interfaces implemented by the type (or its base types) as well as their base interfaces.

Uses the base type matched on.

Uses all interfaces that have names matched by implementation type name. Matches Foo to IFoo, SuperFooExtended to IFoo and IFooExtended etc

Uses the first interface of a type. This method has non-deterministic behavior when type implements more than one interface!

Uses to lookup the sub interface. For example: if you have IService and IProductService : ISomeInterface, IService, ISomeOtherInterface. When you call FromInterface(typeof(IService)) then IProductService will be used. Useful when you want to register _all_ your services and but not want to specify all of them.

Uses base type to lookup the sub interface.

Assigns a custom service selection strategy.

Uses the type itself.

Sets component lifestyle to specified one.

Sets component lifestyle to per thread.

Sets component lifestyle to scoped per explicit scope.

Sets component lifestyle to scoped per component .

Sets component lifestyle to scoped per nearest component on the resolution stack where implementation type is assignable to .

Sets component lifestyle to pooled. If or are not set default values will be used.

Sets component lifestyle to singleton.

Sets component lifestyle to transient.

Assigns the supplied service types.

Entry point to fluent way to register, by convention, multiple concrete (non-abstract) classes (that include also delegate types). Use static methods on the class to fluently build registration.

Prepares to register types from a list of types.

The list of types. The corresponding

Prepares to register types from a list of types.

The list of types. The corresponding

Prepares to register types from an assembly.

The assembly. The corresponding

Prepares to register types from an assembly containing the type.

The type belonging to the assembly. The corresponding

Prepares to register types from an assembly containing the type.

The type belonging to the assembly. The corresponding

Prepares to register types from assemblies found in a given directory that meet additional optional restrictions.

Scans current assembly and all referenced assemblies with the same first part of the name.

Assemblies are considered to belong to the same application based on the first part of the name. For example if the method is called from within MyApp.exe and MyApp.exe references MyApp.SuperFeatures.dll, mscorlib.dll and ThirdPartyCompany.UberControls.dll the MyApp.exe and MyApp.SuperFeatures.dll will be scanned for components, and other assemblies will be ignored.

Prepares to register types from an assembly.

The assembly name. The corresponding

Prepares to register types from the assembly containing the code invoking this method.

The corresponding

Factory for creating objects. Use static methods on the class to fluently build registration.

Creates a component registration for the

Type of the service. The component registration.

Creates a component registration for the

Types of the service. The component registration. B

Creates a component registration for the

Types of the service. The component registration.

Creates a component registration for the service type.

The service type. The component registration.

Creates a component registration for the service types.

The primary service type. The forwarded type. The component registration.

Creates a component registration for the service types.

The primary service type. The first forwarded type. The second forwarded type. The component registration.

Creates a component registration for the service types.

The primary service type. The first forwarded type. The second forwarded type. The third forwarded type. The component registration.

Creates a component registration for the service types.

The primary service type. The first forwarded type. The second forwarded type. The third forwarded type. The fourth forwarded type. The component registration.

Helper method for filtering components based on presence of an Attribute.

container.Register( Classes.FromThisAssembly() .Where(Component.HasAttribute<UserAttribute>) );

Helper method for filtering components based on presence of an Attribute and value of predicate on that attribute.

container.Register( Classes.FromThisAssembly() .Where(Component.HasAttribute<UserAttribute>(u => u.SomeFlag)) );

Determines if the component is a Castle component, that is - if it has a .

true if the service is a Castle Component. This method is usually used as argument for method.

Creates a predicate to check if a component is in a namespace.

The namespace. true if the component type is in the namespace.

Creates a predicate to check if a component is in a namespace.

The namespace. If set to true, will also include types from subnamespaces. true if the component type is in the namespace.

Creates a predicate to check if a component shares a namespace with another.

The component type to test namespace against. true if the component is in the same namespace.

Creates a predicate to check if a component shares a namespace with another.

The component type to test namespace against. If set to true, will also include types from subnamespaces. true if the component is in the same namespace.

Creates a predicate to check if a component shares a namespace with another.

The component type to test namespace against. true if the component is in the same namespace.

Creates a predicate to check if a component shares a namespace with another.

The component type to test namespace against. If set to true, will also include types from subnamespaces. true if the component is in the same namespace.

Registration for a single type as a component with the kernel. You can create a new registration with the factory.

The service type

Initializes a new instance of the class.

The concrete type that implements the service. To set the implementation, use .

The implementation of the service.

Set the lifestyle of this component. For example singleton and transient (also known as 'factory').

The with lifestyle.

The name of the component. Will become the key for the component in the kernel. To set the name, use . If not set, the of the will be used as the key to register the component.

The name.

Set proxy for this component.

The proxy.

Set a custom which creates and destroys the component.

Adds the attribute descriptor.

The key. The value.

Adds the descriptor.

The descriptor.

Creates an attribute descriptor.

The attribute key.

Apply more complex configuration to this component registration.

The config nodes.

Apply more complex configuration to this component registration.

The configuration .

Defines additional dependencies for the component. Those can be any of , and . Use the static methods on class to define the dependencies. See the example attached.

The dependency. Artificial example showing how to specify a service override. See other methods on class for more options. DependsOn(Dependency.OnComponent(typeof(IRepository), typeof(IntranetRepository)));

Defines additional dependencies for the component. Those can be any combibation of , and . Use the static methods on class to define the dependencies. See the example attached.

The dependencies. Artificial example showing how to specify three different dependencies. If any of the methods shown is not self explanatory consult its documentation.

DependsOn(Dependency.OnAppSettingsValue("connectionString", "intranet-connection-string"),
            		Dependency.OnComponent(typeof(IRepository), typeof(IntranetRepository)),
            		Dependency.OnValue("applicationName", "My Application"));

Uses a dictionary of key/value pairs, to specify custom dependencies.

Uses an (anonymous) object as a dictionary, to specify custom dependencies.

Allows custom dependencies to by defined dyncamically. Calling this overload is synonymous to using

The delegate used for providing dynamic parameters.

Allows custom dependencies to by defined dynamically with releasing capability. Calling this overload is synonymous to using

The delegate used for providing dynamic parameters.

Allows custom dependencies to by defined dynamically with releasing capability. Calling this overload is synonymous to using

The delegate used for providing dynamic parameters. Use when resolving components from in order to detect cycles.

Allows custom dependencies to by defined dynamically.

The delegate used for providing dynamic parameters.

Allows custom dependencies to by defined dynamically with releasing capability.

The delegate used for providing dynamic parameters.

Allows custom dependencies to by defined dynamically with releasing capability.

The delegate used for providing dynamic parameters. Use when resolving components from in order to detect cycles.

Sets for this component.

The extended properties.

Sets for this component.

The extended properties.

Sets for this component.

The extendend properties as key/value pairs.

Adds as additional services to be exposed by this component.

The types to forward.

Adds as additional service to be exposed by this component.

The forwarded type. The component registration.

Adds and as additional services to be exposed by this component.

The first forwarded type. The second forwarded type. The component registration.

Adds , and as additional services to be exposed by this component.

The first forwarded type. The second forwarded type. The third forwarded type. The component registration.

Adds , , and as additional services to be exposed by this component.

The first forwarded type. The second forwarded type. The third forwarded type. The fourth forwarded type. The component registration.

Adds as additional services to be exposed by this component.

The types to forward.

Sets the concrete type that implements the service to . If not set, the class service type or first registered interface will be used as the implementation for this component.

The type that is the implementation for the service.

Sets the concrete type that implements the service to . If not set, the class service type or first registered interface will be used as the implementation for this component.

The type that is the implementation for the service.

Sets the concrete type that implements the service to . If not set, the class service type or first registered interface will be used as the implementation for this component.

The type that is the implementation for the service. Provides ability to close open generic service. Ignored when registering closed or non-generic component.

Sets the concrete type that implements the service to . If not set, the class service type or first registered interface will be used as the implementation for this component.

The type that is the implementation for the service. Provides ability to select if open generic component supports particular closed version of a service.

Sets the concrete type that implements the service to . If not set, the class service type or first registered interface will be used as the implementation for this component.

The type that is the implementation for the service. Provides ability to close open generic service. Ignored when registering closed or non-generic component. Provides ability to select if open generic component supports particular closed version of a service.

Assigns an existing instance as the component for this registration.

The component instance.

Set the interceptors for this component.

The interceptors.

Set the interceptors for this component.

The interceptors.

Set the interceptor for this component.

Sets component lifestyle to specified one.

Sets component lifestyle to per thread.

Sets component lifestyle to scoped per explicit scope. If is provided, it will be used to access scope for the component. Otherwise the default scope accessor will be used.

Sets component lifestyle to scoped per explicit scope.

Sets component lifestyle to scoped per farthest component on the resolution stack where implementation type is assignable to .

Sets component lifestyle to scoped per nearest component on the resolution stack where implementation type is assignable to .

Sets component lifestyle to scoped per scope determined by

Custom algorithm for selection which component higher up the resolution stack should be the root of the lifetime scope for current component's instances. The delegate will be invoked when current component is about to be resolved and will be passed set of handlers to components higher up the resolution stack. It ought to return one which it designages as the root which shall scope the lifetime of current component's instance, or null

Sets component lifestyle to pooled. If or are not set default values will be used.

Sets component lifestyle to singleton.

Sets component lifestyle to transient.

Set a name of this registration. This is required if you have multiple components for a given service and want to be able to resolve some specific ones. Then you'd provide the name so that Windsor knows which one of the bunch you know. Otherwise don't bother setting the name. If not set, the of the will be used as the key to register the component.

The name of this registration. Names have to be globally unique in the scope of the container.

This method as opposed to should be used by tools like facilities when the name is not provided by the user, but autogenerated and user has no interest in seing this name, for example in diagnostics reports. Set a name of this registration. This is required if you have multiple components for a given service and want to be able to resolve some specific ones. Then you'd provide the name so that Windsor knows which one of the bunch you know. Otherwise don't bother setting the name. If not set, the of the will be used as the key to register the component.

The name of this registration. Names have to be globally unique in the scope of the container.

Stores a set of which will be invoked when the component is created and before it's returned from the container.

A set of actions to be executed right after the component is created and before it's returned from the container.

Stores a set of which will be invoked when the component is created and before it's returned from the container.

A set of actions to be executed right after the component is created and before it's returned from the container.

Stores a set of which will be invoked when the component is created and before it's returned from the container.

A set of actions to be executed right after the component is created and before it's returned from the container.

Stores a set of which will be invoked when the component is destroyed which means when it's released or it's lifetime scope ends. Notice that usage of this method will cause instsances of the component to be tracked, even if they wouldn't be otherwise.

A set of actions to be executed when the component is destroyed.

Services that are already present in the container will be skipped. If no new service is left the registration will not happen at all.

With the overwrite.

Sets the interceptor selector for this component.

Uses a factory to instantiate the component

Factory type. This factory has to be registered in the kernel. Implementation type. Factory invocation

Uses a factory method to instantiate the component.

Implementation type Factory method When set to true container will not assume ownership of this component, will not track it not apply and lifecycle concerns to it.

Uses a factory method to instantiate the component.

Implementation type Factory method When set to true container will not assume ownership of this component, will not track it not apply and lifecycle concerns to it.

Uses a factory method to instantiate the component.

Implementation type Factory method When set to true container will not assume ownership of this component, will not track it not apply and lifecycle concerns to it.

Uses a factory method to instantiate the component.

Implementation type Factory method

Registers this component with the .

The kernel.

Overrides default behavior by making the current component the default for every service it exposes. The allows user to narrow down the number of services which should be make defaults.

Invoked for each service exposed by given component if returns true this component will be the default for that service. When specified for multiple components for any given service the one registered after will override the one selected before.

Overrides default behavior by making the current component the default for every service it exposes.

When specified for multiple components for any given service the one registered after will override the one selected before.

Overrides default behavior by making the current component the fallback for every service it exposes that returns true for. That is if another, non-fallback, component will be registered exposing any of these same services as this component, that other component will take precedence over this one, regardless of order in which they are registered.

Invoked for each service exposed by given component if returns true this component will be the fallback for that service.

Overrides default behavior by making the current component the fallback for every service it exposes. That is if another, non-fallback, component will be registered exposing any of the same services as this component, that other component will take precedence over this one, regardless of order in which they are registered

Filters (settable) properties of the component's implementation type to ignore.

Predicate finding properties to ignore. If it returns true the property will not be added to collection and Windsor will never try to set it.

Filters (settable) properties of the component's implementation type to expose in the container as mandatory dependencies

Predicate finding properties. If it returns true the property will be added to collection and Windsor will make it a mandatory dependency.

Filters (settable) properties of the component's implementation type to ignore.

Predicate finding properties to ignore. If it returns true the property will not be added to collection and Windsor will never try to set it.

Filters (settable) properties of the component's implementation type to expose in the container as mandatory dependencies

Predicate finding properties. If it returns true the property will be added to collection and Windsor will make it a mandatory dependency.

Filters (settable) properties of the component's implementation type to expose in the container and specifies if matched properties are considered mandatory.

Rules for deciding whether given properties are exposed in the container or ignored and if they are mandatory, that is Windsor will only successfully resole the component if it can provide value for all of these properties.

A non-generic . You can create a new registration with the factory.

Represents a configuration child.

Applies the configuration node.

The configuration.

Represents a configuration attribute.

Applies the configuration node.

The configuration.

Create a with name.

The attribute name. The new

Represents a named attribute.

Builds the with name/value.

The attribute value. The new

Builds the with name/value.

The attribute value. The new

Represents a configuration child.

Create a with name.

The child name. The new

Represents a named child.

Applies the configuration node.

The configuration.

Builds the with name/value.

The child value. The new

Builds the with name/value.

The child value. The new

Builds the with name/config.

The child configuration. The new

Builds the with name/config.

The child nodes. The new

Represents a simple child node.

Applies the configuration node.

The configuration.

Represents a complex child node.

Applies the configuration node.

The configuration.

Represents a compound child node.

Applies the configuration node.

The configuration.

Specifies that value should be used to satisfy dependencies matched by . The value is provided as a string and will be converted to appropriate type when resolving.

Specifies that value from application configuration file's appSettings section named should be used to satisfy dependencies matched by . The value is provided as a string and will be converted to appropriate type when resolving.

Specifies that component registered with should be used to satisfy dependencies matched by

Specifies that components registered with should be used to satisfy collection dependencies matched by

Specifies that value should be used to satisfy dependencies matched by

Selects a set of types from an assembly.

When called also non-public types will be scanned.

Usually it is not recommended to register non-public types in the container so think twice before using this option.

Describes the source of types to register.

Allows a type to be registered multiple times.

Returns the descriptor for accepting a type.

The base type. The descriptor for the type.

Returns the descriptor for accepting a type.

The base type. The descriptor for the type.

Returns the descriptor for accepting a type.

One or more base types. To be accepted a type must implement at least one of the given base types. The descriptor for the type.