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

---

API Differences between 3.2.0 and 5.0.0-beta001

254 Additions 98 Removals

Castle.Core

• public sealed class ComponentModel : GraphNode
  • public Arguments CustomDependencies { get; }
  • public IDictionary CustomDependencies { get; }
  • public Arguments ExtendedProperties { get; }
  • public IDictionary ExtendedProperties { get; }
  • public ComponentModel(ComponentName name, ICollection<Type> services, Type implementation, Arguments extendedProperties)
  • public ComponentModel(ComponentName name, ICollection<Type> services, Type implementation, IDictionary extendedProperties)
• public class CustomLifestyleAttribute : LifestyleAttribute
  • public Type LifestyleHandlerType { get; }
• public class LifecycleConcernsCollection
  • public void Remove(ICommissionConcern concern)
  • public void Remove(IDecommissionConcern concern)
• public enum LifestyleType
  • PerWebRequest = 5
• public sealed class PerWebRequestAttribute : LifestyleAttribute
  • public PerWebRequestAttribute()

Castle.Core.Internal

• public abstract class Constants
  • public static string DefaultComponentForServiceFilter { get; }
  • public static object DefaultComponentForServiceFilter { get; }
  • public static string FallbackComponentForServiceFilter { get; }
  • public static object FallbackComponentForServiceFilter { get; }
  • public static string PropertyFilters { get; }
  • public static string ScopeAccessorType { get; }
  • public static string ScopeRootSelector { get; }
  • public static object PropertyFilters { get; }
  • public static object ScopeAccessorType { get; }
  • public static object ScopeRootSelector { get; }
  • protected Constants()
• public static class ReflectionUtil
  • public static readonly Type[] OpenGenericArrayInterfaces
  • public static TAttribute[] GetAttributes<TAttribute>(this MemberInfo item, bool inherit) where TAttribute : Attribute
  • public static TAttribute[] GetAttributes<TAttribute>(this MemberInfo item) where TAttribute : Attribute
  • public static Assembly[] GetLoadedAssemblies()
• public class SimpleThreadSafeCollection<T>
• public class SimpleThreadSafeSet<T>

Castle.Facilities.Startable

• public interface IStartFlagInternal
• public class StartableFacility : AbstractFacility
  • public class StartableEvents
  • public static bool IsStartable(IHandler handler)
  • public void DeferredStart(StartFlag flag)
• public class StartFlag : IStartFlagInternal

Castle.Facilities.TypedFactory

• public class DefaultTypedFactoryComponentSelector : ITypedFactoryComponentSelector
  • protected virtual Func<IKernelInternal, IReleasePolicy, object> BuildFactoryComponent(MethodInfo method, string componentName, Type componentType, Arguments additionalArguments)
  • protected virtual Arguments GetArguments(MethodInfo method, object[] arguments)
  • protected virtual Func<IKernelInternal, IReleasePolicy, object> BuildFactoryComponent(MethodInfo method, string componentName, Type componentType, IDictionary additionalArguments)
  • protected virtual IDictionary GetArguments(MethodInfo method, object[] arguments)
• public class TypedFactoryComponentResolver
  • protected readonly Arguments additionalArguments
  • protected readonly IDictionary additionalArguments
  • public TypedFactoryComponentResolver(string componentName, Type componentType, Arguments additionalArguments, bool fallbackToResolveByTypeIfNameNotFound, Type actualSelectorType)
  • public TypedFactoryComponentResolver(string componentName, Type componentType, IDictionary additionalArguments, bool fallbackToResolveByTypeIfNameNotFound, Type actualSelectorType)

Castle.Facilities.TypedFactory.Internal

• public class DelegateFactory : ILazyComponentLoader
  • public IRegistration Load(string name, Type service, Arguments arguments)
  • public IRegistration Load(string name, Type service, IDictionary arguments)

Castle.MicroKernel

• public class Arguments : IDictionary, ICollection, IEnumerable, ICloneable
  • protected IDictionary arguments
  • public Arguments()
  • public Arguments(Arguments arguments)
  • public static Arguments FromNamed(IEnumerable<KeyValuePair<string, object>> arguments)
  • public static Arguments FromProperties(object instance)
  • public static Arguments FromTyped(IEnumerable<KeyValuePair<Type, object>> arguments)
  • public static Arguments FromTyped(IEnumerable<object> arguments)
  • public ICollection Keys { get; }
  • public ICollection Values { get; }
  • public Arguments(object namedArgumentsAsAnonymousType, IArgumentsComparer[] customComparers)
  • public Arguments(IDictionary values, IArgumentsComparer[] customComparers)
  • public Arguments(object[] typedArguments, IArgumentsComparer[] customComparers)
  • public Arguments(IArgumentsComparer[] customComparers)
  • public Arguments Add(IEnumerable<KeyValuePair<object, object>> arguments)
  • public Arguments AddNamed(string key, object value)
  • public Arguments AddNamed(IEnumerable<KeyValuePair<string, object>> arguments)
  • public Arguments AddProperties(object instance)
  • public Arguments AddTyped(Type key, object value)
  • public Arguments AddTyped<TDependencyType>(TDependencyType value)
  • public Arguments AddTyped(IEnumerable<object> arguments)
  • public Arguments AddTyped(object[] arguments)
  • public void Clear()
  • public IEnumerator<KeyValuePair<object, object>> GetEnumerator()
  • protected virtual Arguments CreateDeepCopy()
  • public IDictionaryEnumerator GetEnumerator()
• public class DefaultKernel : MarshalByRefObject, IKernelInternal, IKernel, IKernelEvents, IDisposable
  • public virtual object this[string key] { get; }
  • public virtual object this[Type service] { get; }
  • public virtual void AddComponent(string key, Type classType)
  • public void AddComponent(string key, Type classType, LifestyleType lifestyle)
  • public void AddComponent(string key, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
  • public virtual void AddComponent(string key, Type serviceType, Type classType)
  • public void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle)
  • public void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
  • public void AddComponent<T>()
  • public void AddComponent<T>(LifestyleType lifestyle)
  • public void AddComponent<T>(LifestyleType lifestyle, bool overwriteLifestyle)
  • public void AddComponent<T>(Type serviceType)
  • public void AddComponent<T>(Type serviceType, LifestyleType lifestyle)
  • public void AddComponent<T>(Type serviceType, LifestyleType lifestyle, bool overwriteLifestyle)
  • public void AddComponentInstance(string key, object instance)
  • public void AddComponentInstance(string key, Type serviceType, object instance)
  • public void AddComponentInstance(string key, Type serviceType, Type classType, object instance)
  • public void AddComponentInstance<T>(object instance)
  • public void AddComponentInstance<T>(Type serviceType, object instance)
  • public virtual void AddComponentWithExtendedProperties(string key, Type classType, IDictionary extendedProperties)
  • public virtual void AddComponentWithExtendedProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
  • public virtual IKernel AddFacility(string key, IFacility facility)
  • public IKernel AddFacility<T>(string key) where T : IFacility
  • public IKernel AddFacility<T>(string key, Action<T> onCreate) where T : IFacility
  • protected CreationContext CreateCreationContext(IHandler handler, Type requestedType, Arguments additionalArguments, CreationContext parent, IReleasePolicy policy)
  • protected CreationContext CreateCreationContext(IHandler handler, Type requestedType, IDictionary additionalArguments, CreationContext parent, IReleasePolicy policy)
  • public virtual IHandler[] GetHandlers()
  • public object Resolve(string key, IDictionary arguments)
  • public object Resolve(string key, object argumentsAsAnonymousType)
  • public virtual object Resolve(string key, Type service, Arguments arguments)
  • public T Resolve<T>(Arguments arguments)
  • public virtual object Resolve(string key, Type service, IDictionary arguments)
  • public T Resolve<T>(IDictionary arguments)
  • public T Resolve<T>(object argumentsAsAnonymousType)
  • public T Resolve<T>(string key, Arguments arguments)
  • public T Resolve<T>(string key, IDictionary arguments)
  • public object Resolve(Type service, Arguments arguments)
  • public object Resolve(Type service, IDictionary arguments)
  • public object Resolve(Type service, object argumentsAsAnonymousType)
  • public Array ResolveAll(Type service, Arguments arguments)
  • public TService[] ResolveAll<TService>(Arguments arguments)
  • public Array ResolveAll(Type service, IDictionary arguments)
  • public Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • public TService[] ResolveAll<TService>(object argumentsAsAnonymousType)
  • public TService[] ResolveAll<TService>(IDictionary arguments)
  • protected object ResolveComponent(IHandler handler, Type service, Arguments additionalArguments, IReleasePolicy policy)
  • protected object ResolveComponent(IHandler handler, Type service, IDictionary additionalArguments, IReleasePolicy policy)
• public interface IComponentModelBuilder
  • ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, Arguments extendedProperties)
  • ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, IDictionary extendedProperties)
• public interface IKernel : IKernelEvents, IDisposable
  • object this[string key] { get; }
  • object this[Type service] { get; }
  • void AddComponent(string key, Type classType)
  • void AddComponent(string key, Type classType, LifestyleType lifestyle)
  • void AddComponent(string key, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
  • void AddComponent(string key, Type serviceType, Type classType)
  • void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle)
  • void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
  • void AddComponent<T>()
  • void AddComponent<T>(LifestyleType lifestyle)
  • void AddComponent<T>(LifestyleType lifestyle, bool overwriteLifestyle)
  • void AddComponent<T>(Type serviceType)
  • void AddComponent<T>(Type serviceType, LifestyleType lifestyle)
  • void AddComponent<T>(Type serviceType, LifestyleType lifestyle, bool overwriteLifestyle)
  • void AddComponentInstance<T>(object instance)
  • void AddComponentInstance<T>(Type serviceType, object instance)
  • void AddComponentInstance(string key, object instance)
  • void AddComponentInstance(string key, Type serviceType, object instance)
  • void AddComponentInstance(string key, Type serviceType, Type classType, object instance)
  • void AddComponentWithExtendedProperties(string key, Type classType, IDictionary extendedProperties)
  • void AddComponentWithExtendedProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
  • IKernel AddFacility(string key, IFacility facility)
  • IKernel AddFacility<T>(string key) where T : IFacility
  • IKernel AddFacility<T>(string key, Action<T> onCreate) where T : IFacility
  • IHandler[] GetHandlers()
  • object Resolve(string key, object argumentsAsAnonymousType)
  • object Resolve(string key, IDictionary arguments)
  • object Resolve(Type service, Arguments arguments)
  • object Resolve(Type service, IDictionary arguments)
  • object Resolve(Type service, object argumentsAsAnonymousType)
  • T Resolve<T>(Arguments arguments)
  • T Resolve<T>(IDictionary arguments)
  • T Resolve<T>(object argumentsAsAnonymousType)
  • T Resolve<T>(string key, Arguments arguments)
  • object Resolve(string key, Type service, Arguments arguments)
  • T Resolve<T>(string key, IDictionary arguments)
  • object Resolve(string key, Type service, IDictionary arguments)
  • Array ResolveAll(Type service, Arguments arguments)
  • Array ResolveAll(Type service, IDictionary arguments)
  • Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • TService[] ResolveAll<TService>(Arguments arguments)
  • TService[] ResolveAll<TService>(IDictionary arguments)
  • TService[] ResolveAll<TService>(object argumentsAsAnonymousType)
• public interface IKernelInternal : IKernel, IKernelEvents, IDisposable
  • IHandler LoadHandlerByName(string key, Type service, Arguments arguments)
  • IHandler LoadHandlerByType(string key, Type service, Arguments arguments)
  • IHandler LoadHandlerByName(string key, Type service, IDictionary arguments)
  • IHandler LoadHandlerByType(string key, Type service, IDictionary arguments)
  • object Resolve(Type service, Arguments arguments, IReleasePolicy policy, bool ignoreParentContext = false)
  • object Resolve(string key, Type service, Arguments arguments, IReleasePolicy policy)
  • Array ResolveAll(Type service, Arguments arguments, IReleasePolicy policy)
  • object Resolve(Type service, IDictionary arguments, IReleasePolicy policy)
  • object Resolve(string key, Type service, IDictionary arguments, IReleasePolicy policy)
  • Array ResolveAll(Type service, IDictionary arguments, IReleasePolicy policy)

Castle.MicroKernel.ComponentActivator

• public class WebUserControlComponentActivator : DefaultComponentActivator
  • public WebUserControlComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)

Castle.MicroKernel.Context

• public class CreationContext : MarshalByRefObject, ISubDependencyResolver
  • public Arguments AdditionalArguments { get; }
  • public IDictionary AdditionalArguments { get; }
  • public CreationContext(IHandler handler, IReleasePolicy releasePolicy, Type requestedType, Arguments additionalArguments, ITypeConverter converter, CreationContext parent)
  • public CreationContext(IHandler handler, IReleasePolicy releasePolicy, Type requestedType, IDictionary additionalArguments, ITypeConverter converter, CreationContext parent)

Castle.MicroKernel.Handlers

• public class DefaultGenericHandler : AbstractHandler
  • public IHandler ConvertToClosedGenericHandler(Type service, CreationContext openGenericContext)

Castle.MicroKernel.Internal

• public class LazyEx<T> : Lazy<T>, IDisposable
  • public LazyEx(IKernel kernel, Arguments arguments)
  • public LazyEx(IKernel kernel, IDictionary arguments)
  • public LazyEx(IKernel kernel, string overrideComponentName, Arguments arguments)
  • public LazyEx(IKernel kernel, string overrideComponentName, IDictionary arguments)

Castle.MicroKernel.Lifestyle

• public class PerWebRequestLifestyleModule : IHttpModule
  • public PerWebRequestLifestyleModule()
  • protected void Application_EndRequest(object sender, EventArgs e)
  • public void Dispose()
  • public void Init(HttpApplication context)
• public static class PerWebRequestLifestyleModuleRegistration
  • public static void Run()
• public class WebRequestScopeAccessor : IScopeAccessor, IDisposable
  • public WebRequestScopeAccessor()
  • public void Dispose()
  • public ILifetimeScope GetScope(CreationContext context)

Castle.MicroKernel.Lifestyle.Scoped

• public class CallContextLifetimeScope : ILifetimeScope, IDisposable, ISerializable
  • public CallContextLifetimeScope()
  • public CallContextLifetimeScope(IKernel container)
  • public CallContextLifetimeScope(IWindsorContainer container)

Castle.MicroKernel.ModelBuilder

• public class DefaultComponentModelBuilder : IComponentModelBuilder
  • public ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, Arguments extendedProperties)
  • public ComponentModel BuildModel(ComponentName name, Type[] services, Type classType, IDictionary extendedProperties)

Castle.MicroKernel.ModelBuilder.Descriptors

• public class CustomDependencyDescriptor : IComponentModelDescriptor
  • public CustomDependencyDescriptor(Arguments arguments)
  • public CustomDependencyDescriptor(IDictionary dictionary)

Castle.MicroKernel.Registration

• public static class AllTypes
  • public static FromTypesDescriptor From(IEnumerable<Type> types)
  • public static FromTypesDescriptor From(Type[] types)
  • public static FromAssemblyDescriptor FromAssembly(Assembly assembly)
  • public static FromAssemblyDescriptor FromAssemblyContaining(Type type)
  • public static FromAssemblyDescriptor FromAssemblyContaining<T>()
  • public static FromAssemblyDescriptor FromAssemblyInDirectory(AssemblyFilter filter)
  • public static FromAssemblyDescriptor FromAssemblyNamed(string assemblyName)
  • public static FromAssemblyDescriptor FromThisAssembly()
  • public static AllTypesOf Of(Type basedOn)
  • public static AllTypesOf Of<T>()
  • public static AllTypesOf Pick()
  • public static FromTypesDescriptor Pick(IEnumerable<Type> types)
• public class AllTypesOf
  • public BasedOnDescriptor From(IEnumerable<Type> types)
  • public BasedOnDescriptor From(Type[] types)
  • public BasedOnDescriptor FromAssembly(Assembly assembly)
  • public BasedOnDescriptor FromAssemblyNamed(string assemblyName)
  • public BasedOnDescriptor Pick(IEnumerable<Type> types)
• public class BasedOnDescriptor : IRegistration
  • public BasedOnDescriptor BasedOn<T>()
  • public BasedOnDescriptor BasedOn(Type basedOn)
  • public BasedOnDescriptor LifestylePerWebRequest()
  • public BasedOnDescriptor Where(Predicate<Type> accepted)
• public static class Classes
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication(Assembly rootAssembly)
• public static class ComponentDependencyRegistrationExtensions
  • public static IDictionary Insert(this IDictionary arguments, string key, object value)
  • public static IDictionary Insert(this IDictionary arguments, Type dependencyType, object value)
  • public static IDictionary InsertAnonymous(this IDictionary arguments, object namedArgumentsAsAnonymousType)
  • public static IDictionary InsertTyped<TDependencyType>(this IDictionary arguments, TDependencyType value)
  • public static IDictionary InsertTypedCollection(this IDictionary arguments, object[] typedArgumentsArray)
• public class ComponentRegistration<TService> : IRegistration
  • public ComponentRegistration<TService> ActAs(object[] actors)
  • public ComponentRegistration<TService> DependsOn(Arguments dependencies)
  • public ComponentRegistration<TService> LifestylePerWebRequest()
  • public ComponentRegistration<TService> Parameters(Parameter[] parameters)
  • public ComponentRegistration<TService> Properties(Predicate<PropertyInfo> filter)
  • public ComponentRegistration<TService> Properties(Predicate<PropertyInfo> filter, bool isRequired)
  • public ComponentRegistration<TService> Properties(Func<ComponentModel, PropertyInfo, bool> filter, bool isRequired)
  • public ComponentRegistration<TService> UsingFactory<TFactory, TServiceImpl>(Func<TFactory, TServiceImpl> factory) where TServiceImpl : TService
  • public ComponentRegistration<TService> ServiceOverrides(ServiceOverride[] overrides)
  • public ComponentRegistration<TService> ServiceOverrides(IDictionary overrides)
  • public ComponentRegistration<TService> ServiceOverrides(object anonymous)
  • public ComponentRegistration<TService> UsingFactory<TFactory, TServiceImpl>(Converter<TFactory, TServiceImpl> factory) where TServiceImpl : TService
  • public ComponentRegistration<TService> UsingFactoryMethod<TImpl>(Func<IKernel, TImpl> factoryMethod, bool managedExternally = false) where TImpl : TService
  • public ComponentRegistration<TService> UsingFactoryMethod<TImpl>(Converter<IKernel, TImpl> factoryMethod, bool managedExternally = false) where TImpl : TService
• public sealed delegate DynamicParametersDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, Arguments arguments, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual void Invoke(IKernel kernel, Arguments arguments)
  • public virtual void Invoke(IKernel kernel, IDictionary parameters)
• public sealed delegate DynamicParametersResolveDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, Arguments arguments, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, Arguments arguments)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, IDictionary parameters)
• public sealed delegate DynamicParametersWithContextResolveDelegate : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, CreationContext creationContext, Arguments arguments, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(IKernel kernel, CreationContext creationContext, IDictionary parameters, AsyncCallback callback, object object)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, CreationContext creationContext, Arguments arguments)
  • public virtual ComponentReleasingDelegate Invoke(IKernel kernel, CreationContext creationContext, IDictionary parameters)
• public static class Types
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication(Assembly rootAssembly)

Castle.MicroKernel.Registration.Lifestyle

• public class LifestyleGroup<TService> : RegistrationGroup<TService>
  • public ComponentRegistration<TService> PerWebRequest { get; }

Castle.MicroKernel.Resolvers

• public interface ILazyComponentLoader
  • IRegistration Load(string name, Type service, Arguments arguments)
  • IRegistration Load(string name, Type service, IDictionary arguments)
• public class LazyOfTComponentLoader : ILazyComponentLoader
  • public IRegistration Load(string name, Type service, Arguments arguments)
  • public IRegistration Load(string name, Type service, IDictionary arguments)

Castle.MicroKernel.SubSystems.Conversion

• public class TypeNameConverter : AbstractTypeConverter
  • protected virtual bool ShouldSkipAssembly(AssemblyName assemblyName)

Castle.Windsor

• public interface IWindsorContainer : IDisposable
  • object this[string key] { get; }
  • object this[Type service] { get; }
  • IWindsorContainer AddComponent(string key, Type classType)
  • IWindsorContainer AddComponent(string key, Type serviceType, Type classType)
  • IWindsorContainer AddComponent<T>()
  • IWindsorContainer AddComponent<T>(string key)
  • IWindsorContainer AddComponent<I, T>()
  • IWindsorContainer AddComponent<I, T>(string key)
  • IWindsorContainer AddComponentLifeStyle(string key, Type classType, LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle(string key, Type serviceType, Type classType, LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle<T>(LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle<T>(string key, LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle<I, T>(LifestyleType lifestyle)
  • IWindsorContainer AddComponentLifeStyle<I, T>(string key, LifestyleType lifestyle)
  • IWindsorContainer AddComponentProperties<I, T>(IDictionary extendedProperties)
  • IWindsorContainer AddComponentProperties<I, T>(string key, IDictionary extendedProperties)
  • IWindsorContainer AddComponentWithProperties(string key, Type classType, IDictionary extendedProperties)
  • IWindsorContainer AddComponentWithProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
  • IWindsorContainer AddComponentWithProperties<T>(IDictionary extendedProperties)
  • IWindsorContainer AddComponentWithProperties<T>(string key, IDictionary extendedProperties)
  • IWindsorContainer AddFacility(string idInConfiguration, IFacility facility)
  • IWindsorContainer AddFacility<TFacility>(string idInConfiguration) where TFacility : IFacility
  • IWindsorContainer AddFacility<TFacility>(string idInConfiguration, Action<TFacility> configureFacility) where TFacility : IFacility
  • object Resolve(Type service, Arguments arguments)
  • object Resolve(Type service, IDictionary arguments)
  • object Resolve(Type service, object argumentsAsAnonymousType)
  • T Resolve<T>(Arguments arguments)
  • T Resolve<T>(IDictionary arguments)
  • T Resolve<T>(object argumentsAsAnonymousType)
  • T Resolve<T>(string key, Arguments arguments)
  • object Resolve(string key, Type service, Arguments arguments)
  • T Resolve<T>(string key, IDictionary arguments)
  • T Resolve<T>(string key, object argumentsAsAnonymousType)
  • object Resolve(string key, Type service, IDictionary arguments)
  • object Resolve(string key, Type service, object argumentsAsAnonymousType)
  • object Resolve(string key, IDictionary arguments)
  • object Resolve(string key, object argumentsAsAnonymousType)
  • Array ResolveAll(Type service, Arguments arguments)
  • T[] ResolveAll<T>(Arguments arguments)
  • Array ResolveAll(Type service, IDictionary arguments)
  • Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • T[] ResolveAll<T>(IDictionary arguments)
  • T[] ResolveAll<T>(object argumentsAsAnonymousType)
• public class WindsorContainer : MarshalByRefObject, IWindsorContainer, IDisposable
  • public virtual object this[string key] { get; }
  • public virtual object this[Type service] { get; }
  • public virtual IWindsorContainer AddComponent(string key, Type classType)
  • public virtual IWindsorContainer AddComponent(string key, Type serviceType, Type classType)
  • public IWindsorContainer AddComponent<T>()
  • public IWindsorContainer AddComponent<T>(string key)
  • public IWindsorContainer AddComponent<I, T>(string key)
  • public IWindsorContainer AddComponent<I, T>()
  • public IWindsorContainer AddComponentLifeStyle(string key, Type classType, LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle(string key, Type serviceType, Type classType, LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle<T>(LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle<I, T>(LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle<T>(string key, LifestyleType lifestyle)
  • public IWindsorContainer AddComponentLifeStyle<I, T>(string key, LifestyleType lifestyle)
  • public IWindsorContainer AddComponentProperties<I, T>(IDictionary extendedProperties)
  • public IWindsorContainer AddComponentProperties<I, T>(string key, IDictionary extendedProperties)
  • public virtual IWindsorContainer AddComponentWithProperties(string key, Type classType, IDictionary extendedProperties)
  • public virtual IWindsorContainer AddComponentWithProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
  • public IWindsorContainer AddComponentWithProperties<T>(IDictionary extendedProperties)
  • public IWindsorContainer AddComponentWithProperties<T>(string key, IDictionary extendedProperties)
  • public virtual IWindsorContainer AddFacility(string idInConfiguration, IFacility facility)
  • public IWindsorContainer AddFacility<T>(string idInConfiguration) where T : IFacility
  • public IWindsorContainer AddFacility<T>(string idInConfiguration, Action<T> configureFacility) where T : IFacility
  • public virtual object Resolve(Type service, Arguments arguments)
  • public virtual object Resolve(Type service, IDictionary arguments)
  • public virtual object Resolve(Type service, object argumentsAsAnonymousType)
  • public virtual object Resolve(string key, Type service, Arguments arguments)
  • public T Resolve<T>(Arguments arguments)
  • public virtual T Resolve<T>(string key, Arguments arguments)
  • public virtual object Resolve(string key, Type service, IDictionary arguments)
  • public virtual object Resolve(string key, Type service, object argumentsAsAnonymousType)
  • public T Resolve<T>(IDictionary arguments)
  • public T Resolve<T>(object argumentsAsAnonymousType)
  • public virtual T Resolve<T>(string key, IDictionary arguments)
  • public virtual T Resolve<T>(string key, object argumentsAsAnonymousType)
  • public virtual object Resolve(string key, IDictionary arguments)
  • public virtual object Resolve(string key, object argumentsAsAnonymousType)
  • public Array ResolveAll(Type service, Arguments arguments)
  • public T[] ResolveAll<T>(Arguments arguments)
  • public Array ResolveAll(Type service, IDictionary arguments)
  • public Array ResolveAll(Type service, object argumentsAsAnonymousType)
  • public T[] ResolveAll<T>(IDictionary arguments)
  • public T[] ResolveAll<T>(object argumentsAsAnonymousType)
• public static class WindsorContainerExtensions

Castle.Windsor.Installer

• public class FromAssembly
  • public static IWindsorInstaller InThisApplication(Assembly rootAssembly)
  • public static IWindsorInstaller InThisApplication(Assembly rootAssembly, InstallerFactory installerFactory)