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

---

API Differences between 4.0.0 and 3.0.0.2001

296 Additions 118 Removals

Castle.Core

• public class ComponentDependencyModel : DependencyModel
  • public ComponentDependencyModel(string referencedComponentName)
  • public ComponentDependencyModel(string referencedComponentName, Type serviceType)
• public sealed class ComponentModel : GraphNode
  • public const string GenericImplementationMatchingStrategy = "generic.matching"
• public class ComponentName
  • public static ComponentName DefaultFor(Type componentType)
  • public static string DefaultNameFor(Type componentType)
• public sealed class ComponentProxyBehaviorAttribute : Attribute
  • public bool UseMarshalByRefProxy { get; set; }
• public class CustomLifestyleAttribute : LifestyleAttribute
  • public Type CustomLifestyleType { get; }
• public class DependencyModel
  • protected ParameterModel parameterModel
  • protected string reference
  • public bool IsValueType { get; }
  • public bool IsPrimitiveTypeDependency { get; }
  • public string Reference { get; }
  • public string ReferencedComponentName { get; }
  • public IHandler GetHandler(IKernel kernel)
• public class DependencyModelCollection : IMutableCollection<DependencyModel>, IEnumerable<DependencyModel>, IEnumerable
  • public int Count { get; }
• public sealed class DoNotSelectAttribute : Attribute
  • public DoNotSelectAttribute()
• public class InterceptorReference : IReference<IInterceptor>, IEquatable<InterceptorReference>
  • protected string ServiceOverrideComponent { get; }
  • protected Type ServiceType { get; }
• public class InterceptorReferenceCollection : IMutableCollection<InterceptorReference>, IEnumerable<InterceptorReference>, IEnumerable
  • public int Count { get; }
• public enum LifestyleType
  • PerWebRequest = 5
• public class ParameterModelCollection : IEnumerable<ParameterModel>, IEnumerable
  • public IEnumerator GetEnumerator()
• public sealed class PerWebRequestAttribute : LifestyleAttribute
• public sealed delegate PropertyDependencyFilter : MulticastDelegate
  • public PropertyDependencyFilter(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder buildDependencyCallback, AsyncCallback callback, object object)
  • public virtual PropertySet[] EndInvoke(IAsyncResult result)
  • public virtual PropertySet[] Invoke(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder buildDependencyCallback)
• public class PropertyDependencyModel : DependencyModel
  • public PropertyInfo Property { get; }
  • public PropertyDependencyModel(PropertyInfo property, bool isOptional)
• public enum PropertyFilter
  • Default = 0
  • IgnoreAll = 3
  • IgnoreBase = 4
  • RequireAll = 1
  • RequireBase = 2
• public sealed delegate PropertySetBuilder : MulticastDelegate
  • public PropertySetBuilder(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(PropertyInfo property, bool isOptional, AsyncCallback callback, object object)
  • public virtual PropertySet EndInvoke(IAsyncResult result)
  • public virtual PropertySet Invoke(PropertyInfo property, bool isOptional)
• public sealed class ScopedAttribute : LifestyleAttribute
  • public Type ScopeAccessorType { get; set; }
• public class StandardPropertyFilters
  • public StandardPropertyFilters()
  • public static PropertyDependencyFilter Create(PropertyFilter filter)
  • public static PropertySet[] Default(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder propertySetBuilder)
  • public static PropertyDependencyFilter FromObsoleteFunction(Func<ComponentModel, PropertyInfo, bool> filter, bool isRequired)
  • public static ICollection<PropertyDependencyFilter> GetPropertyFilters(ComponentModel componentModel, bool createIfMissing)
  • public static PropertySet[] IgnoreAll(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder propertySetBuilder)
  • public static PropertySet[] IgnoreBase(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder propertySetBuilder)
  • public static PropertyDependencyFilter IgnoreSelected(Func<ComponentModel, PropertyInfo, bool> selector)
  • public static PropertySet[] RequireAll(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder propertySetBuilder)
  • public static PropertySet[] RequireBase(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder propertySetBuilder)
  • public static PropertyDependencyFilter RequireSelected(Func<ComponentModel, PropertyInfo, bool> selector)

Castle.Core.Internal

• public static class ComponentModelExtensions
  • public static Predicate<Type> GetDefaultComponentForServiceFilter(this ComponentModel component)
  • public static Predicate<Type> GetFallbackComponentForServiceFilter(this ComponentModel component)
• public abstract class Constants
  • public static string ExceptionHelpLink { get; }
  • public static object FallbackComponentForServiceFilter { get; }
  • public static string GenericImplementationMatchingStrategy { get; }
  • public static string GenericServiceStrategy { get; }
• public static class ExceptionHelper
  • public static Exception SetUp(this Exception exception)
• public class GraphNode : IVertex
  • public IVertex[] Adjacencies { get; }
  • public GraphNode[] Dependers { get; }
• public static class HelpfulExceptionsUtil
  • public static Exception TrackInstanceCalledMultipleTimes(object instance, Burden burden)
• public interface IMutableCollection<T> : IEnumerable<T>, IEnumerable
  • int Count { get; }
  • void Add(T item)
  • bool Remove(T item)
• public static class LifestyleExtensions
  • public static Type GetScopeAccessorType(this ComponentModel model)
• public static class ReflectionUtil
  • public static readonly Type[] OpenGenericArrayInterfaces
  • public static TAttribute[] GetAttributes<TAttribute>(this MemberInfo item) where TAttribute : Attribute
  • public static TAttribute[] GetAttributes<TAttribute>(this MemberInfo item, bool inherit) where TAttribute : Attribute
  • public static Type[] GetAvailableTypes(this Assembly assembly, bool includeNonExported = false)
  • public static Type[] GetAvailableTypesOrdered(this Assembly assembly, bool includeNonExported = false)
  • public static Assembly[] GetLoadedAssemblies()
  • public static object Instantiate(this ConstructorInfo ctor, object[] ctorArgs)
• public class SegmentedList<T>
  • public SegmentedList(int segmentCount)
  • public void AddFirst(int segmentIndex, T item)
  • public void AddLast(int segmentIndex, T item)
  • public T[] ToArray()
• public class SimpleThreadSafeCollection<T>
  • public int Count { get; }
  • public SimpleThreadSafeCollection()
  • public void Add(T item)
  • public bool Remove(T item)
  • public T[] ToArray()
• public class SimpleThreadSafeDictionary<TKey, TValue>
  • public void Dispose()
  • public bool Contains(TKey key)
  • public TValue[] EjectAllValues()
  • public TValue GetOrThrow(TKey key)
• public class SimpleThreadSafeSet<T>
  • public int Count { get; }
  • public SimpleThreadSafeSet()
  • public bool Add(T item)
  • public bool Remove(T item)
  • public T[] ToArray()
• public static class StringExtensions
  • public static bool EqualsText(this string one, string two)
• public static class TypeUtil
  • public static bool IsPrimitiveType(this Type type)
  • public static bool IsPrimitiveTypeOrCollection(this Type type)
  • public static Type TryMakeGenericType(this Type openGeneric, Type[] arguments)

Castle.Facilities.Startable

• public interface IStartFlagInternal
  • void Init(StartableEvents events)
• public class StartableFacility : AbstractFacility
  • public class StartableEvents
  • public static bool IsStartable(IHandler handler)
  • public void DeferredStart(StartFlag flag)
• public class StartFlag : IStartFlagInternal
  • protected StartableEvents events
  • protected readonly List<IHandler> waitList
  • public StartFlag()
  • protected void CacheHandler(IHandler handler)
  • protected virtual void Init()
  • public virtual void Signal()
  • protected virtual void Start(IHandler handler)
  • protected void StartAll()

Castle.Facilities.TypedFactory

• public class DefaultTypedFactoryComponentSelector : ITypedFactoryComponentSelector
  • protected bool GetMethodsResolveByName { get; protected set; }
  • public DefaultTypedFactoryComponentSelector(bool getMethodsResolveByName = true, bool fallbackToResolveByTypeIfNameNotFound = false)
• public class DelegateFactoryActivator : AbstractComponentActivator, IDependencyAwareActivator
  • public DelegateFactoryActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public DelegateFactoryActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class FactoryAttribute : Attribute
  • public string SelectorComponentName { get; set; }
  • public Type SelectorComponentType { get; set; }
  • public Type SelectorType { get; set; }
  • public FactoryAttribute()
• public class TypedFactoryComponentResolver
  • public TypedFactoryComponentResolver(string componentName, Type componentType, IDictionary additionalArguments, bool fallbackToResolveByTypeIfNameNotFound)
  • public TypedFactoryComponentResolver(string componentName, Type componentType, IDictionary additionalArguments, bool fallbackToResolveByTypeIfNameNotFound, Type actualSelectorType)
• public class TypedFactoryConfiguration
  • public TypedFactoryConfiguration(string defaultComponentSelectorKey)
  • public TypedFactoryConfiguration(string defaultComponentSelectorKey, Type factoryType)
  • public void SelectedWith(Type selectorComponentType)
• public static class TypedFactoryRegistrationExtensions
  • public static ComponentRegistration<TFactoryInterface> AsFactory<TFactoryInterface>(this ComponentRegistration<TFactoryInterface> registration, string selectorComponentName)
  • public static ComponentRegistration<TFactoryInterface> AsFactory<TFactoryInterface>(this ComponentRegistration<TFactoryInterface> registration, Type selectorComponentType)
  • public static ComponentRegistration<TFactoryInterface> AsFactory<TFactoryInterface>(this ComponentRegistration<TFactoryInterface> registration, ITypedFactoryComponentSelector selector)

Castle.Facilities.TypedFactory.Internal

• public class DelegateServiceStrategy : IGenericServiceStrategy
  • public static readonly DelegateServiceStrategy Instance
  • public bool Supports(Type service, ComponentModel component)

Castle.MicroKernel

• public class Arguments : IDictionary, ICollection, IEnumerable
  • public Arguments Clone()
  • protected virtual Arguments CreateDeepCopy()
• public class CircularDependencyException : ComponentResolutionException
  • protected CircularDependencyException(SerializationInfo info, StreamingContext context)
  • public CircularDependencyException(string message, ComponentModel component)
• public class ComponentNotFoundException : ComponentResolutionException
  • public ComponentNotFoundException(string name)
  • public ComponentNotFoundException(string name, Type service, int countOfHandlersForTheService)
  • public ComponentNotFoundException(SerializationInfo info, StreamingContext context)
• public class ComponentReference<T> : IReference<T>
  • public ComponentReference(string dependencyName, string componentName)
  • public ComponentReference(string dependencyName, Type actualComponentType)
  • protected DependencyModel dependencyModel
  • protected readonly string referencedComponentName
  • protected readonly Type referencedComponentType
  • protected virtual Type ComponentType { get; }
  • public ComponentReference(Type componentType)
  • public void Attach(ComponentModel component)
  • public void Detach(ComponentModel component)
• public class ComponentRegistrationException : Exception
  • public ComponentRegistrationException(SerializationInfo info, StreamingContext context)
• public class ComponentResolutionException : Exception
  • public ComponentResolutionException(SerializationInfo info, StreamingContext context)
• public class DefaultKernel : IKernel, IKernelEvents, IDisposable, IKernelInternal
  • public ILogger Logger { get; set; }
  • public event ServiceDelegate EmptyCollectionResolving
  • public DefaultKernel(SerializationInfo info, StreamingContext context)
  • public virtual IHandler AddCustomComponent(ComponentModel model, bool isMetaHandler)
  • public void GetObjectData(SerializationInfo info, StreamingContext context)
  • protected void RegisterHandler(string key, IHandler handler)
• public interface IContextLifestyleManager
  • object GetContextInstance(CreationContext context)
• public interface IHandler : ISubDependencyResolver
  • bool SupportsAssignable(Type service)
• public interface IHandlerFactory
  • IHandler Create(ComponentModel model, bool isMetaHandler)
• public interface IKernelEvents
  • event ServiceDelegate EmptyCollectionResolving
• public interface IKernelInternal : IKernel, IKernelEvents, IDisposable
  • ILogger Logger { get; set; }
  • IHandler AddCustomComponent(ComponentModel model, bool isMetaHandler)
  • IHandler CreateHandler(ComponentModel model)
  • IHandler LoadHandlerByKey(string key, Type service, IDictionary arguments)
  • IHandler LoadHandlerByName(string key, Type service, IDictionary arguments)
  • void RegisterHandler(string key, IHandler handler, bool skipRegistration)
  • void RaiseEventsOnHandlerCreated(IHandler handler)
• public class KernelException : Exception
  • public KernelException(SerializationInfo info, StreamingContext context)
• public sealed delegate ServiceDelegate : MulticastDelegate
  • public ServiceDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Type service, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(Type service)

Castle.MicroKernel.ComponentActivator

• public abstract class AbstractComponentActivator : IComponentActivator
  • public IKernel Kernel { get; }
  • public IKernelInternal Kernel { get; }
  • protected AbstractComponentActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • protected AbstractComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class CollectionActivator<T> : AbstractComponentActivator
• public class ComponentActivatorException : ComponentResolutionException
  • public ComponentActivatorException(string message)
  • public ComponentActivatorException(string message, Exception innerException)
  • public ComponentActivatorException(SerializationInfo info, StreamingContext context)
  • public ComponentModel ComponentModel { get; }
  • public ComponentActivatorException(string message, ComponentModel componentComponentModel)
  • public ComponentActivatorException(string message, Exception innerException, ComponentModel componentModel)
• public class DefaultComponentActivator : AbstractComponentActivator
  • public DefaultComponentActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public DefaultComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class ExternalInstanceActivator : AbstractComponentActivator, IDependencyAwareActivator
  • public ExternalInstanceActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public ExternalInstanceActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class FactoryMethodActivator<T> : DefaultComponentActivator, IDependencyAwareActivator
  • public FactoryMethodActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public FactoryMethodActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class NoResolvableConstructorFoundException : ComponentActivatorException
  • public NoResolvableConstructorFoundException(Type type)
  • public NoResolvableConstructorFoundException(string message, Exception innerException)
  • public NoResolvableConstructorFoundException(SerializationInfo info, StreamingContext context)
  • public NoResolvableConstructorFoundException(Type type, ComponentModel componentModel)
  • public NoResolvableConstructorFoundException(string message, Exception innerException, ComponentModel componentModel)

Castle.MicroKernel.Context

• public class CreationContext : ISubDependencyResolver
  • public void BuildCycleMessageFor(IHandler duplicateHandler, StringBuilder message)

Castle.MicroKernel.Facilities

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

Castle.MicroKernel.Handlers

• public abstract class AbstractHandler : IHandler, ISubDependencyResolver, IExposeDependencyInfo, IDisposable
  • protected virtual void EnsureDependenciesCanBeSatisfied(IDependencyAwareActivator activator)
  • public virtual bool SupportsAssignable(Type service)
• public class CollectionsMetaHandler : IMetaHandler, IDisposable
• public class DefaultGenericHandler : AbstractHandler
  • public DefaultGenericHandler(ComponentModel model, IGenericImplementationMatchingStrategy implementationMatchingStrategy)
  • protected virtual IHandler BuildSubHandler(CreationContext context, Type requestedType)
  • protected IHandler GetSubHandler(CreationContext context, Type genericType)
  • public IGenericServiceStrategy ServiceStrategy { get; }
  • public DefaultGenericHandler(ComponentModel model, IGenericImplementationMatchingStrategy implementationMatchingStrategy, IGenericServiceStrategy serviceStrategy)
  • protected virtual Type[] AdaptServices(Type closedImplementationType, Type requestedType)
  • protected virtual IHandler BuildSubHandler(Type closedImplementationType, Type requestedType)
  • protected IHandler GetSubHandler(Type genericType, Type requestedType)
  • protected bool SupportsAssignable(Type service, Type modelService, Type[] serviceArguments)
• public class DefaultHandlerFactory : IHandlerFactory
  • public IHandler Create(ComponentModel model, bool isMetaHandler)
• public class GenericHandlerTypeMismatchException : HandlerException
  • public GenericHandlerTypeMismatchException(SerializationInfo info, StreamingContext context)
• public class HandlerException : Exception
  • public HandlerException(SerializationInfo info, StreamingContext context)
• public interface IMetaHandler
• public interface IGenericServiceStrategy
  • bool Supports(Type service, ComponentModel component)
• public class ParentHandlerWithChildResolver : IHandler, ISubDependencyResolver, IDisposable
• public class ParentHandlerWrapper : IHandler, ISubDependencyResolver, IDisposable
  • public virtual ComponentModel ComponentModel { get; }
  • public virtual HandlerState CurrentState { get; }
  • public ParentHandlerWrapper(IHandler parentHandler, ISubDependencyResolver childResolver, IReleasePolicy parentReleasePolicy)
  • public virtual bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public virtual void Init(IKernelInternal kernel)
  • public bool IsBeingResolvedInContext(CreationContext context)
  • public virtual bool Release(Burden burden)
  • public virtual object Resolve(CreationContext context)
  • public virtual object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
  • public bool Supports(Type service)
  • public bool SupportsAssignable(Type service)
  • public object TryResolve(CreationContext context)

Castle.MicroKernel.Internal

• public class LazyServiceStrategy : IGenericServiceStrategy
  • public static readonly LazyServiceStrategy Instance
  • public bool Supports(Type service, ComponentModel component)

Castle.MicroKernel.LifecycleConcerns

• public class SupportInitializeConcern : ICommissionConcern

Castle.MicroKernel.Lifestyle

• public static class LifestyleExtensions
  • public static IDisposable RequireScope(this IKernel kernel)
  • public static IDisposable RequireScope(this IWindsorContainer container)
• public class ScopedLifestyleManager : AbstractLifestyleManager
  • public ScopedLifestyleManager()
• public class SingletonLifestyleManager : AbstractLifestyleManager, IContextLifestyleManager
  • public object GetContextInstance(CreationContext context)

Castle.MicroKernel.Lifestyle.Pool

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

Castle.MicroKernel.Lifestyle.Scoped

• public class CallContextLifetimeScope : ILifetimeScope, IDisposable
  • public CallContextLifetimeScope()
• public class CreationContextScopeAccessor : IScopeAccessor, IDisposable
  • public static IHandler NearestScopeRootSelector<TBaseForRoot>(IHandler[] resolutionStack)

Castle.MicroKernel.ModelBuilder

• public static class ComponentModelDescriptorUtil
  • public static readonly string MetaDescriptorsKey
  • public static ICollection<IMetaComponentModelDescriptor> GetMetaDescriptors(this ComponentModel model, bool ensureExists)
  • public static void RemoveMetaDescriptors(ComponentModel model)
• public interface IMetaComponentModelDescriptor
  • void ConfigureComponentModel(IKernel kernel, ComponentModel model)

Castle.MicroKernel.ModelBuilder.Descriptors

• public class InterfaceProxyDescriptor : IComponentModelDescriptor

Castle.MicroKernel.ModelBuilder.Inspectors

• public class ConstructorDependenciesModelInspector : IContributeComponentModelConstruction
  • protected virtual bool IsVisibleToContainer(ConstructorInfo constructor)
• public class LifestyleModelInspector : IContributeComponentModelConstruction
  • protected Type ExtractCustomType(ComponentModel model)
  • protected virtual void ValidateLifestyleManager(Type customLifestyleManager)
  • protected virtual void ValidateTypeFromAttribute(Type typeFromAttribute, Type expectedInterface, string attribute)

Castle.MicroKernel.Proxy

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

Castle.MicroKernel.Registration

• public static class AllTypes
  • public static FromAssemblyDescriptor FromThisAssembly()
• public class BasedOnDescriptor : IRegistration
  • public BasedOnDescriptor LifestyleBoundToNearest<TBaseForRoot>()
  • public BasedOnDescriptor LifestylePerWebRequest()
  • public BasedOnDescriptor OrBasedOn(Type basedOn)
• public static class Classes
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication(Assembly rootAssembly)
  • public static FromAssemblyDescriptor FromThisAssembly()
• public class ComponentRegistration<TService> : IRegistration
  • public ComponentRegistration<TService> DependsOn(Dependency dependency)
  • public ComponentRegistration<TService> ExtendedProperties(Property property)
  • public ComponentRegistration<TService> ImplementedBy(Type type, IGenericServiceStrategy genericServiceStrategy)
  • public ComponentRegistration<TService> ImplementedBy(Type type, IGenericImplementationMatchingStrategy genericImplementationMatchingStrategy, IGenericServiceStrategy genericServiceStrategy)
  • public ComponentRegistration<TService> IsDefault()
  • public ComponentRegistration<TService> IsFallback(Predicate<Type> serviceFilter)
  • public ComponentRegistration<TService> IsFallback()
  • public ComponentRegistration<TService> LifestyleBoundToNearest<TBaseForRoot>()
  • public ComponentRegistration<TService> LifestylePerWebRequest()
  • public ComponentRegistration<TService> Properties(Predicate<PropertyInfo> filter, bool isRequired)
  • public ComponentRegistration<TService> Properties(Func<ComponentModel, PropertyInfo, bool> filter, bool isRequired)
  • public ComponentRegistration<TService> Properties(PropertyFilter filter)
  • public ComponentRegistration<TService> PropertiesIgnore(Func<PropertyInfo, bool> propertySelector)
  • public ComponentRegistration<TService> PropertiesIgnore(Func<ComponentModel, PropertyInfo, bool> propertySelector)
  • public ComponentRegistration<TService> PropertiesRequire(Func<PropertyInfo, bool> propertySelector)
  • public ComponentRegistration<TService> PropertiesRequire(Func<ComponentModel, PropertyInfo, bool> propertySelector)
  • public ComponentRegistration<TService> UsingFactory<TFactory, TServiceImpl>(Converter<TFactory, TServiceImpl> factory) where TServiceImpl : TService
  • public ComponentRegistration<TService> UsingFactory<TFactory, TServiceImpl>(Func<TFactory, TServiceImpl> factory) where TServiceImpl : TService
  • public ComponentRegistration<TService> UsingFactoryMethod<TImpl>(Converter<IKernel, TImpl> factoryMethod, bool managedExternally = false) where TImpl : TService
  • public ComponentRegistration<TService> UsingFactoryMethod<TImpl>(Func<IKernel, TImpl> factoryMethod, bool managedExternally = false) where TImpl : TService
• public sealed class Dependency
  • public static Parameter OnAppSettingsValue(string dependencyName, string settingName)
  • public static Parameter OnAppSettingsValue(string name)
  • public static Property OnResource<TResources>(string dependencyName, string resourceName)
  • public static Property OnResource(string dependencyName, ResourceManager resourceManager, string resourceName)
• public class FromAssemblyDescriptor : FromDescriptor
  • protected readonly IEnumerable<Assembly> assemblies
  • protected bool nonPublicTypes
• public abstract class FromDescriptor : IRegistration
  • protected FromDescriptor(Predicate<Type> additionalFilters)
  • public BasedOnDescriptor BasedOn(Type[] basedOn)
  • public BasedOnDescriptor BasedOn(IEnumerable<Type> basedOn)
  • public BasedOnDescriptor InNamespace(string namespace)
  • public BasedOnDescriptor InNamespace(string namespace, bool includeSubnamespaces)
  • public BasedOnDescriptor InSameNamespaceAs(Type type)
  • public BasedOnDescriptor InSameNamespaceAs(Type type, bool includeSubnamespaces)
  • public BasedOnDescriptor InSameNamespaceAs<T>()
  • public BasedOnDescriptor InSameNamespaceAs<T>(bool includeSubnamespaces)
• public static class Types
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication(Assembly rootAssembly)
  • public static FromAssemblyDescriptor FromThisAssembly()

Castle.MicroKernel.Registration.Lifestyle

• public class LifestyleGroup<TService> : RegistrationGroup<TService>
  • public ComponentRegistration<TService> PerWebRequest { get; }
  • public ComponentRegistration<TService> BoundToNearest<TBaseForRoot>()
  • public ComponentRegistration<TService> Scoped()

Castle.MicroKernel.Registration.Proxy

• public class ItemRegistration<TItem>
  • public ItemRegistration(string itemName)
  • public ItemRegistration()
• public class MixinRegistration : IEnumerable<IReference<object>>, IEnumerable
  • public MixinRegistration Component<TService>()
  • public MixinRegistration Component(Type serviceType)
  • public MixinRegistration Component(string name)
  • public MixinRegistration Service<TService>()
  • public MixinRegistration Service(Type serviceType)
  • public MixinRegistration Service(string name)

Castle.MicroKernel.Releasers

• public class LifecycledComponentsReleasePolicy : IReleasePolicy, IDisposable
  • public LifecycledComponentsReleasePolicy()
  • public LifecycledComponentsReleasePolicy(ITrackedComponentsDiagnostic trackedComponentsDiagnostic)
  • public LifecycledComponentsReleasePolicy(ITrackedComponentsDiagnostic trackedComponentsDiagnostic, ITrackedComponentsPerformanceCounter trackedComponentsPerformanceCounter)
  • public static ITrackedComponentsDiagnostic GetTrackedComponentsDiagnostic(IKernel kernel)
  • public static ITrackedComponentsPerformanceCounter GetTrackedComponentsPerformanceCounter(IPerformanceMetricsFactory perfMetricsFactory)

Castle.MicroKernel.Resolvers

• public class DefaultDependencyResolver : IDependencyResolver, ISubDependencyResolver
  • protected virtual bool CanResolveCore(CreationContext context, ComponentModel model, DependencyModel dependency)
  • protected virtual bool CanResolveFromKernel(CreationContext context, ComponentModel model, DependencyModel dependency)
  • protected virtual object ResolveCore(CreationContext context, ComponentModel model, DependencyModel dependency)
  • protected virtual object ResolveFromKernel(CreationContext context, ComponentModel model, DependencyModel dependency)
• public class DependencyResolverException : Exception
  • public DependencyResolverException(SerializationInfo info, StreamingContext context)

Castle.MicroKernel.Resolvers.SpecializedResolvers

• public class CollectionResolver : ISubDependencyResolver
  • protected readonly bool allowEmptyCollections
  • protected readonly IKernel kernel

Castle.MicroKernel.SubSystems.Conversion

• public class ConverterException : Exception
  • public ConverterException(SerializationInfo info, StreamingContext context)
• public class TypeNameConverter : AbstractTypeConverter
  • protected virtual bool ShouldSkipAssembly(AssemblyName assemblyName)

Castle.MicroKernel.SubSystems.Naming

• public class DefaultNamingSubSystem : AbstractSubSystem, INamingSubSystem, ISubSystem
  • protected struct HandlerWithPriority
  • protected readonly Dictionary<string, IHandler> key2Handler
  • protected readonly Dictionary<string, IHandler> name2Handler
  • protected readonly Dictionary<Type, IHandler> service2Handler
  • protected readonly Dictionary<Type, HandlerWithPriority> service2Handler
  • protected IDictionary<string, IHandler> HandlerByKeyCache { get; }
  • protected IDictionary<string, IHandler> HandlerByNameCache { get; }
  • public IEnumerable<KeyValuePair<Type, IHandler>> GetDefaultComponentsForServices()
  • protected bool IsAssignable(Type thisOne, Type fromThisOne)

Castle.MicroKernel.Util

• public abstract class ReferenceExpressionUtil
  • public static string ExtractComponentKey(string value)
  • public static string ExtractComponentName(string value)

Castle.Windsor

• public class InitializationException : Exception

Castle.Windsor.Configuration.AppDomain

• public class CastleSectionHandler : IConfigurationSectionHandler

Castle.Windsor.Configuration.Interpreters

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

Castle.Windsor.Configuration.Interpreters.XmlProcessor

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

Castle.Windsor.Diagnostics

• public class ComponentDebuggerExtension : IComponentDebuggerExtension
  • public ComponentDebuggerExtension(object[] items)
  • public IEnumerable<object> Attach()
• public class DefaultDiagnosticsSubSystem : AbstractSubSystem, IDiagnosticsHost, IContainerDebuggerExtensionHost, IEnumerable<IContainerDebuggerExtension>, IEnumerable
  • public void Init(IKernelInternal kernel)
  • public void Terminate()
• public class DependencyDuplicate
  • public DependencyModel Dependency1 { get; }
  • public DependencyModel Dependency2 { get; }
  • public DependencyDuplicationReason Reason { get; }
  • public DependencyDuplicate(DependencyModel dependency1, DependencyModel dependency2, DependencyDuplicationReason reason)
  • protected bool Equals(DependencyDuplicate other)
• public enum DependencyDuplicationReason
  • Name = 1
  • NameAndType = 3
  • Reference = 4
  • Type = 2
  • Unspecified = 0
• public class DuplicatedDependenciesDiagnostic : IDuplicatedDependenciesDiagnostic, IDiagnostic<Pair<IHandler, DependencyDuplicate[]>[]>
  • public DuplicatedDependenciesDiagnostic(IKernel kernel)
  • public string GetDetails(DependencyDuplicate duplicates)
  • public Pair<IHandler, DependencyDuplicate[]>[] Inspect()
• public interface IComponentDebuggerExtension
  • IEnumerable<DebuggerViewItem> Attach()
  • IEnumerable<object> Attach()
• public interface IDuplicatedDependenciesDiagnostic : IDiagnostic<Pair<IHandler, DependencyDuplicate[]>[]>
• public class PerformanceMetricsFactory : IPerformanceMetricsFactory
• public class TrackedComponentsDiagnostic : ITrackedComponentsDiagnostic, IDiagnostic<ILookup<IHandler, object>>
  • public TrackedComponentsDiagnostic(ITrackedComponentsPerformanceCounter counter)
  • public void DecrementTrackedInstancesCount()
  • public void Dispose()
  • public void IncrementTrackedInstancesCount()
  • public TrackedComponentsDiagnostic()
• public class TrackedComponentsPerformanceCounterWrapper : ITrackedComponentsPerformanceCounter, IDisposable

Castle.Windsor.Diagnostics.DebuggerViews

• public class ComponentDebuggerView
  • public DebuggerViewItem[] Extensions { get; }
  • public object[] Extensions { get; }
  • public static ComponentDebuggerView BuildRawFor(IHandler handler, string description, IComponentDebuggerExtension[] extensions)
  • public static ComponentDebuggerView BuildRawFor(IHandler handler, string description, object[] items)
• public class ComponentStatusDebuggerViewItem
• public class MismatchedDependencyDebuggerViewItem
• public class ReleasePolicyTrackedObjectsDebuggerViewItem
• public class DebuggerViewItemWithDetails
  • public object Description { get; }
  • public string Details { get; }
  • public object[] Items { get; set; }
  • public string Name { get; }
  • public DebuggerViewItemWithDetails(string name, string description, string details, object[] items)
• public class MasterDetailsDebuggerViewItem
  • public object AMaster { get; }
  • public object[] Details { get; }
  • public MasterDetailsDebuggerViewItem(object master, string masterDescription, string masterName, object[] details)

Castle.Windsor.Diagnostics.Extensions

• public class DuplicatedDependenciesDebuggerExtension : AbstractContainerDebuggerExtension
  • public static string Name { get; }
  • public DuplicatedDependenciesDebuggerExtension()
• public class ReleasePolicyTrackedObjects : AbstractContainerDebuggerExtension
  • public ReleasePolicyTrackedObjects(IPerformanceMetricsFactory perfMetricsFactory)
  • public ReleasePolicyTrackedObjects()

Castle.Windsor.Diagnostics.Helpers

• public class DefaultComponentViewBuilder : IComponentDebuggerExtension
  • public IEnumerable<DebuggerViewItem> Attach()
  • public IEnumerable<object> Attach()

Castle.Windsor.Installer

• public static class Configuration
  • public static ConfigurationInstaller FromAppConfig()
• public class FromAssembly
  • public static IWindsorInstaller InThisApplication()
  • public static IWindsorInstaller InThisApplication(InstallerFactory installerFactory)
  • public static IWindsorInstaller InThisApplication(Assembly rootAssembly)
  • public static IWindsorInstaller InThisApplication(Assembly rootAssembly, InstallerFactory installerFactory)
  • public static IWindsorInstaller This()
  • public static IWindsorInstaller This(InstallerFactory installerFactory)

Castle.Windsor.Proxy

• public class DefaultProxyFactory : AbstractProxyFactory, IDeserializationCallback
  • public DefaultProxyFactory(bool disableSignedModule)
  • public DefaultProxyFactory(ProxyGenerator generator)