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

---

API Differences between 3.0.0.2001 and 3.1.0-RC

71 Additions 101 Removals

Castle.Core

• public class ComponentDependencyModel : DependencyModel
• 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 class DependencyModel
  • protected ParameterModel parameterModel
  • protected string reference
  • public bool IsPrimitiveTypeDependency { get; }
  • public bool IsValueType { get; }
  • public string ReferencedComponentName { get; }
  • public string Reference { get; }
  • public IHandler GetHandler(IKernel kernel)
• public class InterceptorReference : IReference<IInterceptor>, IEquatable<InterceptorReference>
  • protected string ServiceOverrideComponent { get; }
  • protected Type ServiceType { get; }
• public class ParameterModelCollection : IEnumerable<ParameterModel>, IEnumerable
  • public IEnumerator GetEnumerator()
• public sealed delegate PropertyDependencyFilter : MulticastDelegate
• public enum PropertyFilter
• public sealed delegate PropertySetBuilder : MulticastDelegate
• public class StandardPropertyFilters

Castle.Core.Internal

• public static class ComponentModelExtensions
• 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 class GraphNode : MarshalByRefObject, IVertex
  • public IVertex[] Adjacencies { get; }
  • public GraphNode[] Dependers { get; }
• public static class LifestyleExtensions
• public static class ReflectionUtil
  • public static Type[] GetAvailableTypes(this Assembly assembly, bool includeNonExported = false)
  • public static object Instantiate(this ConstructorInfo ctor, object[] ctorArgs)
• public class SegmentedList<T>
• public class SimpleThreadSafeDictionary<TKey, TValue> : IDisposable
  • public bool Contains(TKey key)
  • public TValue[] EjectAllValues()
  • public void Dispose()
• public static class StringExtensions
• public static class TypeUtil
  • public static bool IsPrimitiveType(this Type type)
  • public static Type TryMakeGenericType(this Type openGeneric, Type[] arguments)

Castle.Facilities.TypedFactory

• public class DefaultTypedFactoryComponentSelector : ITypedFactoryComponentSelector
  • protected bool GetMethodsResolveByName { get; protected set; }
  • public DefaultTypedFactoryComponentSelector(bool getMethodsResolveByName = true, bool fallbackToResolveByTypeIfNameNotFound = false)
• public class FactoryAttribute : Attribute
• public class TypedFactoryComponentResolver
  • public TypedFactoryComponentResolver(string componentName, Type componentType, IDictionary additionalArguments, bool fallbackToResolveByTypeIfNameNotFound, Type actualSelectorType)
  • public TypedFactoryComponentResolver(string componentName, Type componentType, IDictionary additionalArguments, bool fallbackToResolveByTypeIfNameNotFound)
• public class TypedFactoryConfiguration
  • public TypedFactoryConfiguration(string defaultComponentSelectorKey, Type factoryType)
  • public TypedFactoryConfiguration(string defaultComponentSelectorKey)
  • 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

Castle.MicroKernel

• public class CircularDependencyException : ComponentResolutionException
  • public CircularDependencyException(string message, ComponentModel component)
• public class ComponentNotFoundException : Exception
  • public ComponentNotFoundException(string name, Type service, int countOfHandlersForTheService)
  • public ComponentNotFoundException(string name)
• public class ComponentReference<T> : IReference<T>
  • protected DependencyModel dependencyModel
  • protected readonly string referencedComponentName
  • protected readonly Type referencedComponentType
  • protected virtual Type ComponentType { get; }
  • public ComponentReference(Type componentType)
  • public ComponentReference(string dependencyName, string componentName)
  • public ComponentReference(string dependencyName, Type actualComponentType)
  • public void Attach(ComponentModel component)
  • public void Detach(ComponentModel component)
• public class DefaultKernel : MarshalByRefObject, IKernelInternal, IKernel, IKernelEvents, IDisposable
  • public event ServiceDelegate EmptyCollectionResolving
• public interface IContextLifestyleManager
• public interface IHandler : ISubDependencyResolver
  • bool SupportsAssignable(Type service)
• public interface IKernelEvents
  • event ServiceDelegate EmptyCollectionResolving
• public interface IKernelInternal : IKernel, IKernelEvents, IDisposable
  • IHandler LoadHandlerByName(string key, Type service, IDictionary arguments)
  • IHandler LoadHandlerByKey(string key, Type service, IDictionary arguments)
• public sealed delegate ServiceDelegate : MulticastDelegate

Castle.MicroKernel.ComponentActivator

• public class ComponentActivatorException : ComponentResolutionException
  • public ComponentModel ComponentModel { get; }
  • public ComponentActivatorException(string message, ComponentModel componentComponentModel)
  • public ComponentActivatorException(string message, Exception innerException, ComponentModel componentModel)
  • public ComponentActivatorException(string message)
  • public ComponentActivatorException(string message, Exception innerException)
• public class NoResolvableConstructorFoundException : ComponentActivatorException
  • public NoResolvableConstructorFoundException(Type type, ComponentModel componentModel)
  • public NoResolvableConstructorFoundException(string message, Exception innerException, ComponentModel componentModel)
  • public NoResolvableConstructorFoundException(Type type)
  • public NoResolvableConstructorFoundException(string message, Exception innerException)

Castle.MicroKernel.Context

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

Castle.MicroKernel.Handlers

• public abstract class AbstractHandler : MarshalByRefObject, IHandler, ISubDependencyResolver, IExposeDependencyInfo, IDisposable
  • 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(CreationContext context, Type closedImplementationType)
  • public DefaultGenericHandler(ComponentModel model, IGenericImplementationMatchingStrategy implementationMatchingStrategy)
  • protected bool SupportsAssignable(Type service, Type modelService, Type[] serviceArguments)
• 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 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
  • public object GetContextInstance(CreationContext context)

Castle.MicroKernel.Registration

• public class ComponentRegistration<TService> : IRegistration
  • 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> Properties(Predicate<PropertyInfo> filter, bool isRequired)
  • public ComponentRegistration<TService> Properties(Func<ComponentModel, PropertyInfo, bool> filter, bool isRequired)
  • public ComponentRegistration<TService> Properties(PropertyFilter filter)
• public abstract class FromDescriptor : IRegistration
  • 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)

Castle.MicroKernel.Registration.Lifestyle

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

Castle.MicroKernel.Registration.Proxy

• public class ItemRegistration<TItem>
  • public ItemRegistration()
  • public ItemRegistration(string itemName)
• 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, ITrackedComponentsPerformanceCounter trackedComponentsPerformanceCounter)
  • public static ITrackedComponentsDiagnostic GetTrackedComponentsDiagnostic(IKernel kernel)
  • public static ITrackedComponentsPerformanceCounter GetTrackedComponentsPerformanceCounter(IPerformanceMetricsFactory perfMetricsFactory)
  • public LifecycledComponentsReleasePolicy(ITrackedComponentsDiagnostic trackedComponentsDiagnostic)

Castle.MicroKernel.Resolvers

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

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, HandlerWithPriority> service2Handler
  • protected readonly Dictionary<Type, IHandler> service2Handler
  • protected IDictionary<string, IHandler> HandlerByNameCache { get; }
  • protected IDictionary<string, IHandler> HandlerByKeyCache { get; }
  • public IEnumerable<KeyValuePair<Type, IHandler>> GetDefaultComponentsForServices()
  • protected bool IsAssignable(Type thisOne, Type fromThisOne)

Castle.MicroKernel.Util

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

Castle.Windsor

• public class InitializationException : Exception
  • public InitializationException()
  • public InitializationException(string message)
  • public InitializationException(Exception innerException)
  • public InitializationException(SerializationInfo info, StreamingContext context)

Castle.Windsor.Diagnostics

• public class DefaultDiagnosticsSubSystem : ISubSystem, IDiagnosticsHost, IContainerDebuggerExtensionHost, IEnumerable<IContainerDebuggerExtension>, IEnumerable
  • public void Init(IKernelInternal kernel)
  • public void Terminate()
• public class TrackedComponentsDiagnostic : ITrackedComponentsDiagnostic, IDiagnostic<ILookup<IHandler, object>>, ITrackedComponentsPerformanceCounter, IDisposable
  • public TrackedComponentsDiagnostic()
  • public TrackedComponentsDiagnostic(ITrackedComponentsPerformanceCounter counter)
  • public void DecrementTrackedInstancesCount()
  • public void Dispose()
  • public void IncrementTrackedInstancesCount()

Castle.Windsor.Diagnostics.Extensions

• public class ReleasePolicyTrackedObjects : AbstractContainerDebuggerExtension
  • public ReleasePolicyTrackedObjects()
  • public ReleasePolicyTrackedObjects(IPerformanceMetricsFactory perfMetricsFactory)

Castle.Windsor.Proxy

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