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

---

API Differences between 3.0.0.3001 and 3.4.0

74 Additions 105 Removals

Castle.Core

• public sealed class ComponentModel : GraphNode
  • public const string GenericImplementationMatchingStrategy = "generic.matching"
• public class CustomLifestyleAttribute : LifestyleAttribute
  • public Type CustomLifestyleType { get; }
• public class DependencyModel
  • public bool IsPrimitiveTypeDependency { get; }
  • public bool IsValueType { get; }
• public class DependencyModelCollection : IEnumerable<DependencyModel>, IEnumerable
  • public int Count { get; }
• public sealed class DoNotSelectAttribute : Attribute
• public class InterceptorReferenceCollection : IEnumerable<InterceptorReference>, IEnumerable
  • public int Count { get; }
• public sealed delegate PropertyDependencyFilter : MulticastDelegate
  • public virtual IAsyncResult BeginInvoke(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder buildDependencyCallback, AsyncCallback callback, object object)
  • public virtual IAsyncResult BeginInvoke(ComponentModel model, PropertyInfo[] properties, PropertySetBuilder buildDependencyCallback, AsyncCallback callback, object object)
  • public virtual PropertySet[] Invoke(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder buildDependencyCallback)
  • public virtual PropertySet[] Invoke(ComponentModel model, PropertyInfo[] properties, PropertySetBuilder buildDependencyCallback)
• public class PropertyDependencyModel : DependencyModel
• public sealed class ScopedAttribute : LifestyleAttribute
  • public Type ScopeAccessorType { get; set; }
• public class StandardPropertyFilters
  • public static PropertySet[] Default(ComponentModel model, ICollection<PropertyInfo> properties, PropertySetBuilder propertySetBuilder)
  • public static PropertyDependencyFilter FromObsoleteFunction(Func<ComponentModel, PropertyInfo, bool> filter, bool isRequired)
  • public static PropertySet[] Default(ComponentModel model, PropertyInfo[] properties, PropertySetBuilder propertySetBuilder)
  • public static PropertyDependencyFilter FromFunction(Func<ComponentModel, PropertyInfo, bool> filter, bool isRequired)
  • 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)
  • public static PropertySet[] IgnoreAll(ComponentModel model, PropertyInfo[] properties, PropertySetBuilder propertySetBuilder)
  • public static PropertySet[] IgnoreBase(ComponentModel model, PropertyInfo[] properties, PropertySetBuilder propertySetBuilder)
  • public static PropertySet[] RequireAll(ComponentModel model, PropertyInfo[] properties, PropertySetBuilder propertySetBuilder)
  • public static PropertySet[] RequireBase(ComponentModel model, PropertyInfo[] properties, PropertySetBuilder propertySetBuilder)

Castle.Core.Internal

• public static class ComponentModelExtensions
• public abstract class Constants
  • public static object FallbackComponentForServiceFilter { get; }
  • public static string GenericImplementationMatchingStrategy { get; }
  • public static string GenericServiceStrategy { get; }
• public static class HelpfulExceptionsUtil
• public interface IMutableCollection<T> : IEnumerable<T>, IEnumerable
• public static class LifestyleExtensions
• public static class ReflectionUtil
  • public static readonly Type[] OpenGenericArrayInterfaces
  • public static Assembly GetAssemblyNamed(string filePath, Predicate<AssemblyName> nameFilter, Predicate<Assembly> assemblyFilter)
  • public static Type[] GetAvailableTypes(this Assembly assembly, bool includeNonExported = false)
  • public static Type[] GetAvailableTypesOrdered(this Assembly assembly, bool includeNonExported = false)
• public class SegmentedList<T>
• public class SimpleThreadSafeCollection<T>
• public class SimpleThreadSafeDictionary<TKey, TValue> : IDisposable
  • public bool Contains(TKey key)
  • public TValue[] EjectAllValues()
  • public void Dispose()
  • public TValue GetOrThrow(TKey key)
• public class SimpleThreadSafeSet<T>
• 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
• 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 DelegateFactoryActivator : AbstractComponentActivator, IDependencyAwareActivator
  • public DelegateFactoryActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public DelegateFactoryActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)

Castle.Facilities.TypedFactory.Internal

• public class DelegateServiceStrategy : IGenericServiceStrategy

Castle.MicroKernel

• public class CircularDependencyException : ComponentResolutionException
  • public CircularDependencyException(string message, ComponentModel component)
• public class DefaultKernel : IKernelInternal, IKernel, IKernelEvents, IDisposable
  • public ILogger Logger { get; set; }
  • public virtual IHandler AddCustomComponent(ComponentModel model, bool isMetaHandler)
  • protected void RegisterHandler(string name, IHandler handler)
• public interface IContextLifestyleManager
• public interface IHandler : ISubDependencyResolver
  • bool SupportsAssignable(Type service)
• public interface IHandlerFactory
  • IHandler Create(ComponentModel model, bool isMetaHandler)
• public interface IKernelInternal : IKernel, IKernelEvents, IDisposable
  • ILogger Logger { get; set; }
  • IHandler AddCustomComponent(ComponentModel model, bool isMetaHandler)
  • IHandler CreateHandler(ComponentModel model)
  • void RaiseEventsOnHandlerCreated(IHandler handler)
  • void RegisterHandler(string key, IHandler handler, bool skipRegistration)

Castle.MicroKernel.ComponentActivator

• public abstract class AbstractComponentActivator : IComponentActivator
  • public IKernelInternal Kernel { get; }
  • public IKernel Kernel { get; }
  • protected AbstractComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • protected AbstractComponentActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class CollectionActivator<T> : AbstractComponentActivator
  • public CollectionActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class DefaultComponentActivator : AbstractComponentActivator
  • public DefaultComponentActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public DefaultComponentActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class ExternalInstanceActivator : AbstractComponentActivator, IDependencyAwareActivator
  • public ExternalInstanceActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public ExternalInstanceActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
• public class FactoryMethodActivator<T> : DefaultComponentActivator, IDependencyAwareActivator
  • public FactoryMethodActivator(ComponentModel model, IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
  • public FactoryMethodActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)

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 CollectionsMetaHandler()
  • public void Dispose()
  • public IHandler GetHandler(Type service, IHandler[] existingHandlers)
  • public void Init(IKernelInternal kernel)
• public class DefaultGenericHandler : AbstractHandler
  • 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 DefaultGenericHandler(ComponentModel model, IGenericImplementationMatchingStrategy implementationMatchingStrategy)
  • protected virtual IHandler BuildSubHandler(CreationContext context, Type requestedType)
  • protected IHandler GetSubHandler(CreationContext context, Type genericType)
• public class DefaultHandlerFactory : IHandlerFactory
  • public IHandler Create(ComponentModel model, bool isMetaHandler)
• public interface IGenericServiceStrategy
• public interface IMetaHandler
  • IHandler GetHandler(Type service, IHandler[] existingHandlers)
  • void Init(IKernelInternal kernel)
• public class ParentHandlerWrapper : IHandler, ISubDependencyResolver, IDisposable
• public class ParentHandlerWithChildResolver : IHandler, ISubDependencyResolver, IDisposable
  • public virtual ComponentModel ComponentModel { get; }
  • public virtual HandlerState CurrentState { get; }
  • public ParentHandlerWithChildResolver(IHandler parentHandler, ISubDependencyResolver childResolver)
  • 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 object TryResolve(CreationContext context)

Castle.MicroKernel.Internal

• public class LazyServiceStrategy : IGenericServiceStrategy

Castle.MicroKernel.Lifestyle

• public class SingletonLifestyleManager : AbstractLifestyleManager
  • public object GetContextInstance(CreationContext context)

Castle.MicroKernel.Lifestyle.Scoped

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

Castle.MicroKernel.ModelBuilder

• public static class ComponentModelDescriptorUtil
• public interface IMetaComponentModelDescriptor

Castle.MicroKernel.ModelBuilder.Descriptors

• public class InterfaceProxyDescriptor : IComponentModelDescriptor
  • public InterfaceProxyDescriptor()
  • public void BuildComponentModel(IKernel kernel, ComponentModel model)
  • public void ConfigureComponentModel(IKernel kernel, ComponentModel model)

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 ValidateTypeFromAttribute(Type typeFromAttribute, Type expectedInterface, string attribute)
  • protected virtual void ValidateLifestyleManager(Type customLifestyleManager)

Castle.MicroKernel.Registration

• public static class AllTypes
  • public static FromAssemblyDescriptor FromAssemblyInDirectory(AssemblyFilter filter)
• public class AssemblyFilter : IAssemblyProvider
  • public AssemblyFilter(string directoryName, string mask = null)
  • public AssemblyFilter FilterByAssembly(Predicate<Assembly> filter)
  • public AssemblyFilter FilterByName(Predicate<AssemblyName> filter)
  • public AssemblyFilter WithKeyToken(string publicKeyToken)
  • public AssemblyFilter WithKeyToken(byte[] publicKeyToken)
  • public AssemblyFilter WithKeyToken(Type typeFromAssemblySignedWithKey)
  • public AssemblyFilter WithKeyToken<TTypeFromAssemblySignedWithKey>()
  • public AssemblyFilter WithKeyToken(Assembly assembly)
• public class BasedOnDescriptor : IRegistration
  • public BasedOnDescriptor LifestyleBoundToNearest<TBaseForRoot>()
  • public BasedOnDescriptor OrBasedOn(Type basedOn)
• public static class Classes
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication()
  • public static FromAssemblyDescriptor FromAssemblyInDirectory(AssemblyFilter filter)
• 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> IsFallback(Predicate<Type> serviceFilter)
  • public ComponentRegistration<TService> IsFallback()
  • public ComponentRegistration<TService> LifestyleBoundToNearest<TBaseForRoot>()
  • 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 sealed class Dependency
  • 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 static class Types
  • public static FromAssemblyDescriptor FromAssemblyInThisApplication()
  • public static FromAssemblyDescriptor FromAssemblyInDirectory(AssemblyFilter filter)

Castle.MicroKernel.Registration.Lifestyle

• public class LifestyleGroup<TService> : RegistrationGroup<TService>
  • public ComponentRegistration<TService> BoundToNearest<TBaseForRoot>()
  • public ComponentRegistration<TService> Scoped()

Castle.MicroKernel.Resolvers.SpecializedResolvers

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

Castle.MicroKernel.SubSystems.Naming

• public class DefaultNamingSubSystem : AbstractSubSystem, INamingSubSystem, ISubSystem
  • protected struct HandlerWithPriority
  • protected readonly Dictionary<Type, HandlerWithPriority> service2Handler
  • protected readonly Dictionary<Type, IHandler> service2Handler
  • protected bool IsAssignable(Type thisOne, Type fromThisOne)

Castle.Windsor.Diagnostics

• public class DependencyDuplicate
• public enum DependencyDuplicationReason
• public class DuplicatedDependenciesDiagnostic : IDuplicatedDependenciesDiagnostic, IDiagnostic<Pair<IHandler, DependencyDuplicate[]>[]>
• public interface IDuplicatedDependenciesDiagnostic : IDiagnostic<Pair<IHandler, DependencyDuplicate[]>[]>

Castle.Windsor.Installer

• public class FromAssembly
  • public static IWindsorInstaller InDirectory(AssemblyFilter filter)
  • public static IWindsorInstaller InDirectory(AssemblyFilter filter, InstallerFactory installerFactory)

Castle.Windsor.Proxy

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