Castle.MicroKernel
Namespace with 41 public types
Classes
                                     Arguments
                                    Represents a collection of named and typed arguments used for dependencies resolved via 
            See: https://github.com/castleproject/Windsor/blob/master/docs/arguments.md
                                
                            
                            
                                
                                     Burden
                                    
                                
                            
                            
                                
                                     CircularDependencyException
                                    Exception throw when a circular dependency is detected
                                
                            
                            
                                
                                     ComponentNotFoundException
                                    Exception threw when a request for a component
              cannot be satisfied because the component does not
              exist in the container
                                
                            
                            
                                
                                     ComponentReference`1
                                    Reference to component obtained from the container.
                                
                            
                            
                                
                                     ComponentRegistrationException
                                    Exception threw when there is a problem
              registering a component
                                
                            
                            
                                
                                     ComponentResolutionException
                                    Exception thrown when resolution process for a component was unsuccessful at some point for whatever reason.
                                
                            
                            
                                
                                     DefaultKernel
                                    Default implementation of . This implementation is complete and also support a kernel hierarchy (sub containers).
                                
                            
                            
                                
                                     InstanceReference`1
                                    Represents a reference to an existing object.
                                
                            
                            
                                
                                     KernelException
                                    Exception threw by Kernel operations that failed
              for some reason.
                                
                            
                        
                        Enumerations
                                     HandlerState
                                    Possible states for a IHandler instance
                                
                            
                        
                        Abstract Classes
                                     AbstractSubSystem
                                    
                                
                            
                            
                                
                                     SubSystemConstants
                                    Holds the keys used by Kernel to register/request 
              a subsystem.
                                
                            
                        
                        Interfaces
                                     IComponentActivator
                                    Implements the instance creation logic. The default
              implementation should rely on an ordinary call to 
              Activator.CreateInstance().
                                
                            
                            
                                
                                     IComponentModelBuilder
                                    Implementors must construct a populated
              instance of ComponentModel by inspecting the component
              and|or the configuration.
                                
                            
                            
                                
                                     IContextLifestyleManager
                                    
                                
                            
                            
                                
                                     IDependencyResolver
                                    Implementors should use a strategy to obtain 
              valid references to properties and/or services 
              requested in the dependency model.
                                
                            
                            
                                
                                     IFacility
                                    Unit of extension. A facility should use 
              the extension points offered by the kernel
              to augment its functionality.
                                
                            
                            
                                
                                     IHandler
                                    Contract for the IHandler, which manages an
              component state and coordinates its creation 
              and destruction (dispatching to activators, lifestyle managers)
                                
                            
                            
                                
                                     IHandlerFactory
                                    Extension point to allow the developer to use his implementation of
                                
                            
                            
                                
                                     IHandlerSelector
                                    Implementors of this interface allow to extend the way the container perform
              component resolution based on some application specific business logic.
                                
                            
                            
                                
                                     IHandlersFilter
                                    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.
                                
                            
                            
                                
                                     IKernel
                                    The IKernel interface exposes all the functionality
              the MicroKernel implements.
                                
                            
                            
                                
                                     IKernelEvents
                                    Summary description for IKernelEvents.
                                
                            
                            
                                
                                     IKernelInternal
                                    Extended contract of kernel, used internally.
                                
                            
                            
                                
                                     ILifestyleManager
                                    The ILifestyleManager implements 
              a strategy for a given lifestyle, like singleton, per-thread
              and transient.
                                
                            
                            
                                
                                     IProxyFactory
                                    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
                                
                            
                            
                                
                                     IProxyFactoryExtension
                                    
                                
                            
                            
                                
                                     IReference`1
                                    Represents obtained just in time object.
                                
                            
                            
                                
                                     IReleasePolicy
                                    Policy managing lifetime of components, and in particular their release process.
                                
                            
                            
                                
                                     ISubDependencyResolver
                                    Implementors should use a strategy to obtain 
              valid references to properties and/or services 
              requested in the dependency model.
                                
                            
                            
                                
                                     ISubSystem
                                    A subsystem is used by the MicroKernel to deal 
              with a specific concern.