diff --git a/lib/Boxes.Integration.XML b/lib/Boxes.Integration.XML
index 8028171..a0d1965 100644
--- a/lib/Boxes.Integration.XML
+++ b/lib/Boxes.Integration.XML
@@ -106,12 +106,83 @@
the package to extract the types from
a set of types which will be used for IoC registration
+
+
+ the selector will indicate what interceptors to apply on a given registration
+
+
+
+
+ find the interceptor types to apply on a registration
+
+ contains all the inforamtion required to see which interceptor types will be returned
+ a distinct list of interceptor types
+
+
+
+ contains information about an interception context
+
+
+
+
+ the contracts which we have registered the service with
+
+
+
+
+ the concrete service which will satisfy the contract
+
+
+
+
+ contains information on when and where to apply an Aspect
+
+
+
+
+ when to apply this interceptor
+
+
+
+
+ the interceptor to apply
+
+
+
+
+ register an interceptor/aspect for AOP
+
+
+
+
+ apply a filter (pattern) to find which types this registration will apply too
+
+ the pattern to find the types this registration applies too
+
+
+
+ the interceptors to apply
+
+ interceptors to apply
+
+
+
+ the interceptor apply
+
+ the interceptor to apply
+
this provides a mechanism to create the required boxes tasks for registration
the IoC builder
+
+
+ set the interceptor selector which can be used with the registration task
+
+ the registration selector
+
create a boxes registration task from the
@@ -120,7 +191,7 @@
- the tenants container setup
+ default container setup
the ioc builder class
@@ -134,6 +205,12 @@
the setup for this area of the application
+
+
+ add an interceptor/aspect to the container
+
+ the registration
+
Register a type (can be as simple as does it implement a Dependency or to apply a filter)
@@ -362,7 +439,7 @@
note this is abstract, it is inherited by the container implementation,
this was to make the API easier to work with
IE new Register() VS new Register[Type, WindsorContainer]()
- the latter is not do friendly
+ the latter is not friendly to do
@@ -641,6 +718,42 @@
all the types of interest
+
+
+ wrappers arround a single pipeline, and offers a simple
+ way to update the tasks the pipeline will carry out.
+
+ the type which the tasks in the pipeline are
+
+
+
+ create wrapper with no tasks
+
+
+
+
+ create wrapper, and add a number of tasks ready for the pipeline
+
+ the tasks for the underlying pipeline
+
+
+
+ update the tasks in the pipeline
+
+ sets the tasks for the pipeline
+
+
+
+ update the tasks in the pipeline
+
+
+
+
+ execute the pipeline
+
+ items to process
+ the collection of items which was passed in
+
Dependency resolver interface to be used by
diff --git a/lib/Boxes.Integration.dll b/lib/Boxes.Integration.dll
index 4a37406..37cc011 100644
Binary files a/lib/Boxes.Integration.dll and b/lib/Boxes.Integration.dll differ
diff --git a/lib/Castle.Core.dll b/lib/Castle.Core.dll
new file mode 100644
index 0000000..24f4b2f
Binary files /dev/null and b/lib/Castle.Core.dll differ
diff --git a/lib/Castle.Core.xml b/lib/Castle.Core.xml
new file mode 100644
index 0000000..b20f738
--- /dev/null
+++ b/lib/Castle.Core.xml
@@ -0,0 +1,4754 @@
+
+
+
+ Castle.Core
+
+
+
+
+ Specifies assignment by reference rather than by copying.
+
+
+
+
+ Suppresses any on-demand behaviors.
+
+
+
+
+ Removes a property if null or empty string, guid or collection.
+
+
+
+
+ Removes a property if matches value.
+
+
+
+
+ Assigns a specific dictionary key.
+
+
+
+
+ Defines the contract for customizing dictionary access.
+
+
+
+
+ Copies the dictionary behavior.
+
+ null if should not be copied. Otherwise copy.
+
+
+
+ Determines relative order to apply related behaviors.
+
+
+
+
+ Defines the contract for updating dictionary values.
+
+
+
+
+ Sets the stored dictionary value.
+
+ The dictionary adapter.
+ The key.
+ The stored value.
+ The property.
+ true if the property should be stored.
+
+
+
+ Contract for value matching.
+
+
+
+
+ Indicates that underlying values are changeable and should not be cached.
+
+
+
+
+ Contract for dictionary initialization.
+
+
+
+
+ Performs any initialization of the
+
+ The dictionary adapter.
+ The dictionary behaviors.
+
+
+
+ Abstract implementation of .
+
+
+
+
+ Conract for traversing a .
+
+
+
+
+ Contract for creating additional Dictionary adapters.
+
+
+
+
+ Contract for manipulating the Dictionary adapter.
+
+
+
+
+ Contract for editing the Dictionary adapter.
+
+
+
+
+ Contract for managing Dictionary adapter notifications.
+
+
+
+
+ Contract for validating Dictionary adapter.
+
+
+
+
+ Defines the contract for building s.
+
+
+
+
+ Builds the dictionary behaviors.
+
+
+
+
+
+ Abstract adapter for the support
+ needed by the
+
+
+
+
+ Adds an element with the provided key and value to the object.
+
+ The to use as the key of the element to add.
+ The to use as the value of the element to add.
+ An element with the same key already exists in the object.
+ key is null.
+ The is read-only.-or- The has a fixed size.
+
+
+
+ Removes all elements from the object.
+
+ The object is read-only.
+
+
+
+ Determines whether the object contains an element with the specified key.
+
+ The key to locate in the object.
+
+ true if the contains an element with the key; otherwise, false.
+
+ key is null.
+
+
+
+ Returns an object for the object.
+
+
+ An object for the object.
+
+
+
+
+ Removes the element with the specified key from the object.
+
+ The key of the element to remove.
+ The object is read-only.-or- The has a fixed size.
+ key is null.
+
+
+
+ Copies the elements of the to an , starting at a particular index.
+
+ The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing.
+ The zero-based index in array at which copying begins.
+ array is null.
+ The type of the source cannot be cast automatically to the type of the destination array.
+ index is less than zero.
+ array is multidimensional.-or- index is equal to or greater than the length of array.-or- The number of elements in the source is greater than the available space from index to the end of the destination array.
+
+
+
+ Returns an enumerator that iterates through a collection.
+
+
+ An object that can be used to iterate through the collection.
+
+
+
+
+ Gets a value indicating whether the object has a fixed size.
+
+
+ true if the object has a fixed size; otherwise, false.
+
+
+
+ Gets a value indicating whether the object is read-only.
+
+
+ true if the object is read-only; otherwise, false.
+
+
+
+ Gets an object containing the keys of the object.
+
+
+ An object containing the keys of the object.
+
+
+
+ Gets an object containing the values in the object.
+
+
+ An object containing the values in the object.
+
+
+
+ Gets or sets the with the specified key.
+
+
+
+
+
+ Gets the number of elements contained in the .
+
+
+ The number of elements contained in the .
+
+
+
+ Gets a value indicating whether access to the is synchronized (thread safe).
+
+
+ true if access to the is synchronized (thread safe); otherwise, false.
+
+
+
+ Gets an object that can be used to synchronize access to the .
+
+
+ An object that can be used to synchronize access to the .
+
+
+
+ Provides a generic collection that supports data binding.
+
+
+ This class wraps the CLR
+ in order to implement the Castle-specific .
+
+ The type of elements in the list.
+
+
+
+ Initializes a new instance of the class
+ using default values.
+
+
+
+
+ Initializes a new instance of the class
+ with the specified list.
+
+
+ An of items
+ to be contained in the .
+
+
+
+
+ Initializes a new instance of the class
+ wrapping the specified instance.
+
+
+ A
+ to be wrapped by the .
+
+
+
+
+ Defines the contract for retrieving dictionary values.
+
+
+
+
+ Gets the effective dictionary value.
+
+ The dictionary adapter.
+ The key.
+ The stored value.
+ The property.
+ true if return only existing.
+ The effective property value.
+
+
+
+ Initializes a new instance of the class
+ that represents a child object in a larger object graph.
+
+
+
+
+
+
+ Contract for dictionary meta-data initialization.
+
+
+
+
+ Initializes the given object.
+
+ The dictionary adapter factory.
+ The dictionary adapter meta.
+
+
+
+
+ Determines whether the given behavior should be included in a new
+ object.
+
+ A dictionary behavior or annotation.
+ True if the behavior should be included; otherwise, false.
+
+ behaviors are always included,
+ regardless of the result of this method.
+
+
+
+
+
+ Checks whether or not collection is null or empty. Assumes colleciton can be safely enumerated multiple times.
+
+
+
+
+
+
+ Constant to use when making assembly internals visible to Castle.Core
+ [assembly: InternalsVisibleTo(CoreInternalsVisible.ToCastleCore)]
+
+
+
+
+ Constant to use when making assembly internals visible to proxy types generated by DynamicProxy. Required when proxying internal types.
+ [assembly: InternalsVisibleTo(CoreInternalsVisible.ToDynamicProxyGenAssembly2)]
+
+
+
+
+ Identifies a property should be represented as a nested component.
+
+
+
+
+ Defines the contract for building typed dictionary keys.
+
+
+
+
+ Builds the specified key.
+
+ The dictionary adapter.
+ The current key.
+ The property.
+ The updated key
+
+
+
+ Applies no prefix.
+
+
+
+
+ Gets or sets the prefix.
+
+ The prefix.
+
+
+
+ Identifies the dictionary adapter types.
+
+
+
+
+ Identifies an interface or property to be pre-fetched.
+
+
+
+
+ Instructs fetching to occur.
+
+
+
+
+ Instructs fetching according to
+
+
+
+
+
+ Gets whether or not fetching should occur.
+
+
+
+
+ Assigns a property to a group.
+
+
+
+
+ Constructs a group assignment.
+
+ The group name.
+
+
+
+ Constructs a group assignment.
+
+ The group name.
+
+
+
+ Gets the group the property is assigned to.
+
+
+
+
+ Assigns a specific dictionary key.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The key.
+
+
+
+ Initializes a new instance of the class.
+
+ The compound key.
+
+
+
+ Assigns a prefix to the keyed properties of an interface.
+
+
+ Key prefixes are not inherited by sub-interfaces.
+
+
+
+
+ Initializes a default instance of the class.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The prefix for the keyed properties of the interface.
+
+
+
+ Gets the prefix key added to the properties of the interface.
+
+
+
+
+ Substitutes part of key with another string.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The old value.
+ The new value.
+
+
+
+ Requests support for multi-level editing.
+
+
+
+
+ Generates a new GUID on demand.
+
+
+
+
+ Support for on-demand value resolution.
+
+
+
+
+ Provides simple string formatting from existing properties.
+
+
+
+
+ Gets the string format.
+
+
+
+
+ Gets the format properties.
+
+
+
+
+ Identifies a property should be represented as a delimited string value.
+
+
+
+
+ Gets the separator.
+
+
+
+
+ Converts all properties to strings.
+
+
+
+
+ Gets or sets the format.
+
+ The format.
+
+
+
+ Suppress property change notifications.
+
+
+
+
+ Contract for property descriptor initialization.
+
+
+
+
+ Performs any initialization of the
+
+ The property descriptor.
+ The property behaviors.
+
+
+
+ Assigns a prefix to the keyed properties using the interface name.
+
+
+
+
+ Manages conversion between property values.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The converter.
+
+
+
+ Gets the effective dictionary value.
+
+ The dictionary adapter.
+ The key.
+ The stored value.
+ The property.
+ true if return only existing.
+ The effective property value.
+
+
+
+
+
+
+
+
+ Uses Reflection.Emit to expose the properties of a dictionary
+ through a dynamic implementation of a typed interface.
+
+
+
+
+ Defines the contract for building typed dictionary adapters.
+
+
+
+
+ Gets a typed adapter bound to the .
+
+ The typed interface.
+ The underlying source of properties.
+ An implementation of the typed interface bound to the dictionary.
+
+ The type represented by T must be an interface with properties.
+
+
+
+
+ Gets a typed adapter bound to the .
+
+ The typed interface.
+ The underlying source of properties.
+ An implementation of the typed interface bound to the dictionary.
+
+ The type represented by T must be an interface with properties.
+
+
+
+
+ Gets a typed adapter bound to the .
+
+ The typed interface.
+ The underlying source of properties.
+ The property descriptor.
+ An implementation of the typed interface bound to the dictionary.
+
+ The type represented by T must be an interface with properties.
+
+
+
+
+ Gets a typed adapter bound to the .
+
+ The typed interface.
+ The underlying source of properties.
+ An implementation of the typed interface bound to the namedValues.
+
+ The type represented by T must be an interface with properties.
+
+
+
+
+ Gets a typed adapter bound to the .
+
+ The typed interface.
+ The underlying source of properties.
+ An implementation of the typed interface bound to the namedValues.
+
+ The type represented by T must be an interface with properties.
+
+
+
+
+ Gets a typed adapter bound to the .
+
+ The typed interface.
+ The underlying source of properties.
+ An implementation of the typed interface bound to the .
+
+ The type represented by T must be an interface with properties.
+
+
+
+
+ Gets a typed adapter bound to the .
+
+ The typed interface.
+ The underlying source of properties.
+ An implementation of the typed interface bound to the .
+
+ The type represented by T must be an interface with properties.
+
+
+
+
+ Gets the associated with the type.
+
+ The typed interface.
+ The adapter meta-data.
+
+
+
+ Gets the associated with the type.
+
+ The typed interface.
+ The property descriptor.
+ The adapter meta-data.
+
+
+
+ Gets the associated with the type.
+
+ The typed interface.
+ Another from which to copy behaviors.
+ The adapter meta-data.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Contract for dictionary validation.
+
+
+
+
+ Determines if is valid.
+
+ The dictionary adapter.
+ true if valid.
+
+
+
+ Validates the .
+
+ The dictionary adapter.
+ The error summary information.
+
+
+
+ Validates the for a property.
+
+ The dictionary adapter.
+ The property to validate.
+ The property summary information.
+
+
+
+ Invalidates any results cached by the validator.
+
+ The dictionary adapter.
+
+
+
+
+
+
+
+
+ Initializes a new instance of the class.
+
+ The name values.
+
+
+
+ Determines whether the object contains an element with the specified key.
+
+ The key to locate in the object.
+
+ true if the contains an element with the key; otherwise, false.
+
+ key is null.
+
+
+
+ Adapts the specified name values.
+
+ The name values.
+
+
+
+
+ Gets a value indicating whether the object is read-only.
+
+
+ true if the object is read-only; otherwise, false.
+
+
+
+ Gets or sets the with the specified key.
+
+
+
+
+
+ Describes a dictionary property.
+
+
+
+
+ Initializes an empty class.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The property.
+ The annotations.
+
+
+
+ Initializes a new instance class.
+
+
+
+
+ Copies an existinginstance of the class.
+
+
+
+
+
+
+ Gets the key.
+
+ The dictionary adapter.
+ The key.
+ The descriptor.
+
+
+
+
+ Gets the property value.
+
+ The dictionary adapter.
+ The key.
+ The stored value.
+ The descriptor.
+ true if return only existing.
+
+
+
+
+ Sets the property value.
+
+ The dictionary adapter.
+ The key.
+ The value.
+ The descriptor.
+
+
+
+
+ Adds a single behavior.
+
+ The behavior.
+
+
+
+ Adds the behaviors.
+
+ The behaviors.
+
+
+
+ Adds the behaviors.
+
+ The behaviors.
+
+
+
+ Copies the behaviors to the other
+
+
+
+
+
+
+ Copies the
+
+
+
+
+
+
+
+
+
+
+ Gets the property name.
+
+
+
+
+ Gets the property type.
+
+
+
+
+ Gets the property.
+
+ The property.
+
+
+
+ Returns true if the property is dynamic.
+
+
+
+
+ Gets additional state.
+
+
+
+
+ Determines if property should be fetched.
+
+
+
+
+ Determines if property must exist first.
+
+
+
+
+ Determines if notifications should occur.
+
+
+
+
+ Gets the property behaviors.
+
+
+
+
+ Gets the type converter.
+
+ The type converter.
+
+
+
+ Gets the extended properties.
+
+
+
+
+ Gets the setter.
+
+ The setter.
+
+
+
+ Gets the key builders.
+
+ The key builders.
+
+
+
+ Gets the setter.
+
+ The setter.
+
+
+
+ Gets the getter.
+
+ The getter.
+
+
+
+ Gets the initializers.
+
+ The initializers.
+
+
+
+ Gets the meta-data initializers.
+
+ The meta-data initializers.
+
+
+
+ Helper class for retrieving attributes.
+
+
+
+
+ Gets the attribute.
+
+ The member.
+ The member attribute.
+
+
+
+ Gets the attributes. Does not consider inherited attributes!
+
+ The member.
+ The member attributes.
+
+
+
+ Gets the type attribute.
+
+ The type.
+ The type attribute.
+
+
+
+ Gets the type attributes.
+
+ The type.
+ The type attributes.
+
+
+
+ Gets the type converter.
+
+ The member.
+
+
+
+
+ Gets the attribute.
+
+ The member.
+ The member attribute.
+
+
+
+ Contract for typed dynamic value resolution.
+
+
+
+
+
+ Contract for dynamic value resolution.
+
+
+
+
+ Supporting Logger levels.
+
+
+
+
+ Logging will be off
+
+
+
+
+ Fatal logging level
+
+
+
+
+ Error logging level
+
+
+
+
+ Warn logging level
+
+
+
+
+ Info logging level
+
+
+
+
+ Debug logging level
+
+
+
+
+ Encapsulates an invocation of a proxied method.
+
+
+
+
+ Gets the value of the argument at the specified .
+
+ The index.
+ The value of the argument at the specified .
+
+
+
+ Returns the concrete instantiation of the on the proxy, with any generic
+ parameters bound to real types.
+
+
+ The concrete instantiation of the on the proxy, or the if
+ not a generic method.
+
+
+ Can be slower than calling .
+
+
+
+
+ Returns the concrete instantiation of , with any
+ generic parameters bound to real types.
+ For interface proxies, this will point to the on the target class.
+
+ The concrete instantiation of , or
+ if not a generic method.
+
+ In debug builds this can be slower than calling .
+
+
+
+
+ Proceeds the call to the next interceptor in line, and ultimately to the target method.
+
+
+ Since interface proxies without a target don't have the target implementation to proceed to,
+ it is important, that the last interceptor does not call this method, otherwise a
+ will be thrown.
+
+
+
+
+ Overrides the value of an argument at the given with the
+ new provided.
+
+
+ This method accepts an , however the value provided must be compatible
+ with the type of the argument defined on the method, otherwise an exception will be thrown.
+
+ The index of the argument to override.
+ The new value for the argument.
+
+
+
+ Gets the arguments that the has been invoked with.
+
+ The arguments the method was invoked with.
+
+
+
+ Gets the generic arguments of the method.
+
+ The generic arguments, or null if not a generic method.
+
+
+
+ Gets the object on which the invocation is performed. This is different from proxy object
+ because most of the time this will be the proxy target object.
+
+
+ The invocation target.
+
+
+
+ Gets the representing the method being invoked on the proxy.
+
+ The representing the method being invoked.
+
+
+
+ For interface proxies, this will point to the on the target class.
+
+ The method invocation target.
+
+
+
+ Gets the proxy object on which the intercepted method is invoked.
+
+ Proxy object on which the intercepted method is invoked.
+
+
+
+ Gets or sets the return value of the method.
+
+ The return value of the method.
+
+
+
+ Gets the type of the target object for the intercepted method.
+
+ The type of the target object.
+
+
+
+ Used during the target type inspection process. Implementors have a chance to customize the
+ proxy generation process.
+
+
+
+
+ Invoked by the generation process to notify that the whole process has completed.
+
+
+
+
+ Invoked by the generation process to notify that a member was not marked as virtual.
+
+ The type which declares the non-virtual member.
+ The non-virtual member.
+
+ This method gives an opportunity to inspect any non-proxyable member of a type that has
+ been requested to be proxied, and if appropriate - throw an exception to notify the caller.
+
+
+
+
+ Invoked by the generation process to determine if the specified method should be proxied.
+
+ The type which declares the given method.
+ The method to inspect.
+ True if the given method should be proxied; false otherwise.
+
+
+
+ Interface describing elements composing generated type
+
+
+
+
+ Performs some basic screening and invokes the
+ to select methods.
+
+
+
+
+
+
+
+
+ Provides functionality for disassembling instances of attributes to CustomAttributeBuilder form, during the process of emiting new types by Dynamic Proxy.
+
+
+
+
+ Disassembles given attribute instance back to corresponding CustomAttributeBuilder.
+
+ An instance of attribute to disassemble
+ corresponding 1 to 1 to given attribute instance, or null reference.
+
+ Implementers should return that corresponds to given attribute instance 1 to 1,
+ that is after calling specified constructor with specified arguments, and setting specified properties and fields with values specified
+ we should be able to get an attribute instance identical to the one passed in . Implementer can return null
+ if it wishes to opt out of replicating the attribute. Notice however, that for some cases, like attributes passed explicitly by the user
+ it is illegal to return null, and doing so will result in exception.
+
+
+
+
+ Handles error during disassembly process
+
+ Type of the attribute being disassembled
+ Exception thrown during the process
+ usually null, or (re)throws the exception
+
+
+
+ Here we try to match a constructor argument to its value.
+ Since we can't get the values from the assembly, we use some heuristics to get it.
+ a/ we first try to match all the properties on the attributes by name (case insensitive) to the argument
+ b/ if we fail we try to match them by property type, with some smarts about convertions (i,e: can use Guid for string).
+
+
+
+
+ We have the following rules here.
+ Try to find a matching type, failing that, if the parameter is string, get the first property (under the assumption that
+ we can convert it.
+
+
+
+
+ Attributes can only accept simple types, so we return null for null,
+ if the value is passed as string we call to string (should help with converting),
+ otherwise, we use the value as is (enums, integer, etc).
+
+
+
+
+ Returns list of all unique interfaces implemented given types, including their base interfaces.
+
+
+
+
+
+
+ Applied to the assemblies saved by in order to persist the cache data included in the persisted assembly.
+
+
+
+
+ Base class that exposes the common functionalities
+ to proxy generation.
+
+
+
+
+ It is safe to add mapping (no mapping for the interface exists)
+
+
+
+
+
+
+
+ Generates a parameters constructor that initializes the proxy
+ state with just to make it non-null.
+
+ This constructor is important to allow proxies to be XML serializable
+
+
+
+
+
+ Generates the constructor for the class that extends
+
+
+
+
+
+
+
+
+ Default implementation of interface producing in-memory proxy assemblies.
+
+
+
+
+ Abstracts the implementation of proxy type construction.
+
+
+
+
+ Creates a proxy type for given , implementing , using provided.
+
+ The class type to proxy.
+ Additional interface types to proxy.
+ The proxy generation options.
+ The generated proxy type.
+
+ Implementers should return a proxy type for the specified class and interfaces.
+ Additional interfaces should be only 'mark' interfaces, that is, they should work like interface proxy without target. (See method.)
+
+ Thrown when or any of is a generic type definition.
+ Thrown when or any of is not public.
+ Note that to avoid this exception, you can mark offending type internal, and define
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.
+
+
+
+
+ Creates a proxy type that proxies calls to members on , implementing , using provided.
+
+ The interface type to proxy.
+ Additional interface types to proxy.
+ Type implementing on which calls to the interface members should be intercepted.
+ The proxy generation options.
+ The generated proxy type.
+
+ Implementers should return a proxy type for the specified interface that 'proceeds' executions to the specified target.
+ Additional interfaces should be only 'mark' interfaces, that is, they should work like interface proxy without target. (See method.)
+
+ Thrown when or any of is a generic type definition.
+ Thrown when or any of is not public.
+ Note that to avoid this exception, you can mark offending type internal, and define
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.
+
+
+
+
+ Creates a proxy type for given and that delegates all calls to the provided interceptors and allows interceptors to switch the actual target of invocation.
+
+ The interface type to proxy.
+ Additional interface types to proxy.
+ The proxy generation options.
+ The generated proxy type.
+
+ Implementers should return a proxy type for the specified interface(s) that delegate all executions to the specified interceptors
+ and uses an instance of the interface as their targets (i.e. ), rather than a class. All classes should then implement interface,
+ to allow interceptors to switch invocation target with instance of another type implementing called interface.
+
+ Thrown when or any of is a generic type definition.
+ Thrown when or any of is not public.
+ Note that to avoid this exception, you can mark offending type internal, and define
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.
+
+
+
+
+ Creates a proxy type for given that delegates all calls to the provided interceptors.
+
+ The interface type to proxy.
+ Additional interface types to proxy.
+ The proxy generation options.
+ The generated proxy type.
+
+ Implementers should return a proxy type for the specified interface and additional interfaces that delegate all executions to the specified interceptors.
+
+ Thrown when or any of is a generic type definition.
+ Thrown when or any of is not public.
+ Note that to avoid this exception, you can mark offending type internal, and define
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.
+
+
+
+
+ Gets or sets the that this logs to.
+
+
+
+
+ Gets the associated with this builder.
+
+ The module scope associated with this builder.
+
+
+
+ Initializes a new instance of the class with new .
+
+
+
+
+ Initializes a new instance of the class.
+
+ The module scope for generated proxy types.
+
+
+
+ Registers custom disassembler to handle disassembly of specified type of attributes.
+
+ Type of attributes to handle
+ Disassembler converting existing instances of Attributes to CustomAttributeBuilders
+
+ When disassembling an attribute Dynamic Proxy will first check if an custom disassembler has been registered to handle attributes of that type,
+ and if none is found, it'll use the .
+
+
+
+
+ Attributes should be replicated if they are non-inheritable,
+ but there are some special cases where the attributes means
+ something to the CLR, where they should be skipped.
+
+
+
+
+ Initializes a new instance of the class.
+
+ Target element. This is either target type or target method for invocation types.
+ The type of the proxy. This is base type for invocation types.
+ The interfaces.
+ The options.
+
+
+
+ Initializes a new instance of the class.
+
+ Type of the target.
+ The interfaces.
+ The options.
+
+
+
+ s
+ Provides appropriate Ldc.X opcode for the type of primitive value to be loaded.
+
+
+
+
+ Provides appropriate Ldind.X opcode for
+ the type of primitive value to be loaded indirectly.
+
+
+
+
+ Emits a load indirect opcode of the appropriate type for a value or object reference.
+ Pops a pointer off the evaluation stack, dereferences it and loads
+ a value of the specified type.
+
+
+
+
+
+
+ Emits a load opcode of the appropriate kind for a constant string or
+ primitive value.
+
+
+
+
+
+
+ Emits a load opcode of the appropriate kind for the constant default value of a
+ type, such as 0 for value types and null for reference types.
+
+
+
+
+ Emits a store indirectopcode of the appropriate type for a value or object reference.
+ Pops a value of the specified type and a pointer off the evaluation stack, and
+ stores the value.
+
+
+
+
+
+
+ Summary description for PropertiesCollection.
+
+
+
+
+ Wraps a reference that is passed
+ ByRef and provides indirect load/store support.
+
+
+
+
+ Summary description for NewArrayExpression.
+
+
+
+
+
+
+
+
+ Provides appropriate Stind.X opcode
+ for the type of primitive value to be stored indirectly.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The name.
+ Type declaring the original event being overriten, or null.
+
+ The add method.
+ The remove method.
+ The attributes.
+
+
+
+ Represents the scope of uniquenes of names for types and their members
+
+
+
+
+ Gets a unique name based on
+
+ Name suggested by the caller
+ Unique name based on .
+
+ Implementers should provide name as closely resembling as possible.
+ Generally if no collision occurs it is suggested to return suggested name, otherwise append sequential suffix.
+ Implementers must return deterministic names, that is when is called twice
+ with the same suggested name, the same returned name should be provided each time. Non-deterministic return
+ values, like appending random suffices will break serialization of proxies.
+
+
+
+
+ Returns new, disposable naming scope. It is responsibilty of the caller to make sure that no naming collision
+ with enclosing scope, or other subscopes is possible.
+
+ New naming scope.
+
+
+
+ Returns the methods implemented by a type. Use this instead of Type.GetMethods() to work around a CLR issue
+ where duplicate MethodInfos are returned by Type.GetMethods() after a token of a generic type's method was loaded.
+
+
+
+
+ Determines whether the specified method is internal.
+
+ The method.
+
+ true if the specified method is internal; otherwise, false.
+
+
+
+
+ Determines whether this assembly has internals visible to dynamic proxy.
+
+ The assembly to inspect.
+
+
+
+ Checks if the method is public or protected.
+
+
+
+
+
+
+ Because we need to cache the types based on the mixed in mixins, we do the following here:
+ - Get all the mixin interfaces
+ - Sort them by full name
+ - Return them by position
+
+ The idea is to have reproducible behavior for the case that mixins are registered in different orders.
+ This method is here because it is required
+
+
+
+
+ Summary description for ModuleScope.
+
+
+
+
+ The default file name used when the assembly is saved using .
+
+
+
+
+ The default assembly (simple) name used for the assemblies generated by a instance.
+
+
+
+
+ Initializes a new instance of the class; assemblies created by this instance will not be saved.
+
+
+
+
+ Initializes a new instance of the class, allowing to specify whether the assemblies generated by this instance
+ should be saved.
+
+ If set to true saves the generated module.
+
+
+
+ Initializes a new instance of the class, allowing to specify whether the assemblies generated by this instance
+ should be saved.
+
+ If set to true saves the generated module.
+ If set to true disables ability to generate signed module. This should be used in cases where ran under constrained permissions.
+
+
+
+ Initializes a new instance of the class, allowing to specify whether the assemblies generated by this instance
+ should be saved and what simple names are to be assigned to them.
+
+ If set to true saves the generated module.
+ If set to true disables ability to generate signed module. This should be used in cases where ran under constrained permissions.
+ The simple name of the strong-named assembly generated by this .
+ The path and file name of the manifest module of the strong-named assembly generated by this .
+ The simple name of the weak-named assembly generated by this .
+ The path and file name of the manifest module of the weak-named assembly generated by this .
+
+
+
+ Initializes a new instance of the class, allowing to specify whether the assemblies generated by this instance
+ should be saved and what simple names are to be assigned to them.
+
+ If set to true saves the generated module.
+ If set to true disables ability to generate signed module. This should be used in cases where ran under constrained permissions.
+ Naming scope used to provide unique names to generated types and their members (usually via sub-scopes).
+ The simple name of the strong-named assembly generated by this .
+ The path and file name of the manifest module of the strong-named assembly generated by this .
+ The simple name of the weak-named assembly generated by this .
+ The path and file name of the manifest module of the weak-named assembly generated by this .
+
+
+
+ Returns a type from this scope's type cache, or null if the key cannot be found.
+
+ The key to be looked up in the cache.
+ The type from this scope's type cache matching the key, or null if the key cannot be found
+
+
+
+ Registers a type in this scope's type cache.
+
+ The key to be associated with the type.
+ The type to be stored in the cache.
+
+
+
+ Gets the key pair used to sign the strong-named assembly generated by this .
+
+
+
+
+
+ Gets the specified module generated by this scope, creating a new one if none has yet been generated.
+
+ If set to true, a strong-named module is returned; otherwise, a weak-named module is returned.
+ A strong-named or weak-named module generated by this scope, as specified by the parameter.
+
+
+
+ Gets the strong-named module generated by this scope, creating a new one if none has yet been generated.
+
+ A strong-named module generated by this scope.
+
+
+
+ Gets the weak-named module generated by this scope, creating a new one if none has yet been generated.
+
+ A weak-named module generated by this scope.
+
+
+
+ Saves the generated assembly with the name and directory information given when this instance was created (or with
+ the and current directory if none was given).
+
+
+
+ This method stores the generated assembly in the directory passed as part of the module information specified when this instance was
+ constructed (if any, else the current directory is used). If both a strong-named and a weak-named assembly
+ have been generated, it will throw an exception; in this case, use the overload.
+
+
+ If this was created without indicating that the assembly should be saved, this method does nothing.
+
+
+ Both a strong-named and a weak-named assembly have been generated.
+ The path of the generated assembly file, or null if no file has been generated.
+
+
+
+ Saves the specified generated assembly with the name and directory information given when this instance was created
+ (or with the and current directory if none was given).
+
+ True if the generated assembly with a strong name should be saved (see );
+ false if the generated assembly without a strong name should be saved (see .
+
+
+ This method stores the specified generated assembly in the directory passed as part of the module information specified when this instance was
+ constructed (if any, else the current directory is used).
+
+
+ If this was created without indicating that the assembly should be saved, this method does nothing.
+
+
+ No assembly has been generated that matches the parameter.
+
+ The path of the generated assembly file, or null if no file has been generated.
+
+
+
+ Loads the generated types from the given assembly into this 's cache.
+
+ The assembly to load types from. This assembly must have been saved via or
+ , or it must have the manually applied.
+
+ This method can be used to load previously generated and persisted proxy types from disk into this scope's type cache, eg. in order
+ to avoid the performance hit associated with proxy generation.
+
+
+
+
+ Users of this should use this lock when accessing the cache.
+
+
+
+
+ Gets the strong-named module generated by this scope, or if none has yet been generated.
+
+ The strong-named module generated by this scope, or if none has yet been generated.
+
+
+
+ Gets the file name of the strongly named module generated by this scope.
+
+ The file name of the strongly named module generated by this scope.
+
+
+
+ Gets the directory where the strongly named module generated by this scope will be saved, or if the current directory
+ is used.
+
+ The directory where the strongly named module generated by this scope will be saved when is called
+ (if this scope was created to save modules).
+
+
+
+ Gets the weak-named module generated by this scope, or if none has yet been generated.
+
+ The weak-named module generated by this scope, or if none has yet been generated.
+
+
+
+ Gets the file name of the weakly named module generated by this scope.
+
+ The file name of the weakly named module generated by this scope.
+
+
+
+ Gets the directory where the weakly named module generated by this scope will be saved, or if the current directory
+ is used.
+
+ The directory where the weakly named module generated by this scope will be saved when is called
+ (if this scope was created to save modules).
+
+
+
+ ProxyBuilder that persists the generated type.
+
+
+ The saved assembly contains just the last generated type.
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Saves the generated assembly to a physical file. Note that this renders the unusable.
+
+ The path of the generated assembly file, or null if no assembly has been generated.
+
+ This method does not support saving multiple files. If both a signed and an unsigned module have been generated, use the
+ respective methods of the .
+
+
+
+
+ Initializes a new instance of the class.
+
+ The hook.
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Provides proxy objects for classes and interfaces.
+
+
+
+
+ Initializes a new instance of the class.
+
+ Proxy types builder.
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the class.
+
+ If true forces all types to be generated into an unsigned module.
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The interceptors called during the invocation of proxied methods.
+ Object proxying calls to members of on object.
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is not an interface type.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method generates new proxy type for each type of , which affects performance. If you don't want to proxy types differently depending on the type of the target
+ use method.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of on object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is not an interface type.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method generates new proxy type for each type of , which affects performance. If you don't want to proxy types differently depending on the type of the target
+ use method.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of type on object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not an interface type.
+ Thrown when given does not implement interface.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method generates new proxy type for each type of , which affects performance. If you don't want to proxy types differently depending on the type of the target
+ use method.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of type on object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not an interface type.
+ Thrown when given does not implement interface.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method generates new proxy type for each type of , which affects performance. If you don't want to proxy types differently depending on the type of the target
+ use method.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ Additional interface types. Calls to their members will be proxied as well.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of and types on object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not an interface type.
+ Thrown when given does not implement interface.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method generates new proxy type for each type of , which affects performance. If you don't want to proxy types differently depending on the type of the target
+ use method.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ Additional interface types. Calls to their members will be proxied as well.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of and types on object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not an interface type.
+ Thrown when given does not implement interface.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method generates new proxy type for each type of , which affects performance. If you don't want to proxy types differently depending on the type of the target
+ use method.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+ Interceptors can use interface to provide other target for method invocation than default .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of type on object or alternative implementation swapped at runtime by an interceptor.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not an interface type.
+ Thrown when given does not implement interface.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+ Interceptors can use interface to provide other target for method invocation than default .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of type on object or alternative implementation swapped at runtime by an interceptor.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is not an interface type.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+ Interceptors can use interface to provide other target for method invocation than default .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of type on object or alternative implementation swapped at runtime by an interceptor.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is not an interface type.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+ Interceptors can use interface to provide other target for method invocation than default .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ Additional interface types. Calls to their members will be proxied as well.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of and types on object or alternative implementation swapped at runtime by an interceptor.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not an interface type.
+ Thrown when given does not implement interface.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+ Interceptors can use interface to provide other target for method invocation than default .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of type on object or alternative implementation swapped at runtime by an interceptor.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not an interface type.
+ Thrown when given does not implement interface.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on object with given .
+ Interceptors can use interface to provide other target for method invocation than default .
+
+ Type of the interface implemented by which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ Additional interface types. Calls to their members will be proxied as well.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of and types on object or alternative implementation swapped at runtime by an interceptor.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not an interface type.
+ Thrown when given does not implement interface.
+ Thrown when no default constructor exists on actual type of object.
+ Thrown when default constructor of actual type of throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on target object generated at runtime with given .
+
+ Type of the interface which will be proxied.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of types on generated target object.
+
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is not an interface type.
+
+ Since this method uses an empty-shell implementation of interfaces to proxy generated at runtime, the actual implementation of proxied methods must be provided by given implementations.
+ They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call , since there's no actual implementation to proceed with.
+ As a result of that also at least one implementation must be provided.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on target object generated at runtime with given .
+
+ Type of the interface which will be proxied.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of types on generated target object.
+
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is not an interface type.
+
+ Since this method uses an empty-shell implementation of interfaces to proxy generated at runtime, the actual implementation of proxied methods must be provided by given implementations.
+ They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call , since there's no actual implementation to proceed with.
+ As a result of that also at least one implementation must be provided.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on target object generated at runtime with given .
+
+ Type of the interface which will be proxied.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of types on generated target object.
+
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is not an interface type.
+
+ Since this method uses an empty-shell implementation of interfaces to proxy generated at runtime, the actual implementation of proxied methods must be provided by given implementations.
+ They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call , since there's no actual implementation to proceed with.
+ As a result of that also at least one implementation must be provided.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on target object generated at runtime with given .
+
+ Type of the interface which will be proxied.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of type on generated target object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not an interface type.
+
+ Since this method uses an empty-shell implementation of interfaces to proxy generated at runtime, the actual implementation of proxied methods must be provided by given implementations.
+ They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call , since there's no actual implementation to proceed with.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on target object generated at runtime with given .
+
+ Type of the interface which will be proxied.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of type on generated target object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not an interface type.
+
+ Since this method uses an empty-shell implementation of interfaces to proxy generated at runtime, the actual implementation of proxied methods must be provided by given implementations.
+ They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call , since there's no actual implementation to proceed with.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on target object generated at runtime with given .
+
+ Type of the interface which will be proxied.
+ Additional interface types. Calls to their members will be proxied as well.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of and types on generated target object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not an interface type.
+
+ Since this method uses an empty-shell implementation of interfaces to proxy generated at runtime, the actual implementation of proxied methods must be provided by given implementations.
+ They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call , since there's no actual implementation to proceed with.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on target object generated at runtime with given .
+
+ Type of the interface which will be proxied.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of on generated target object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not an interface type.
+
+ They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call , since there's no actual implementation to proceed with.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to members of interface on target object generated at runtime with given .
+
+ Type of the interface which will be proxied.
+ The proxy generation options used to influence generated proxy type and object.
+ Additional interface types. Calls to their members will be proxied as well.
+ The interceptors called during the invocation of proxied methods.
+
+ Object proxying calls to members of and types on generated target object.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given array is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not an interface type.
+
+ Since this method uses an empty-shell implementation of to proxy generated at runtime, the actual implementation of proxied methods must be provided by given implementations.
+ They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call , since there's no actual implementation to proceed with.
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The target object, calls to which will be intercepted.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ Additional interface types. Calls to their members will be proxied as well.
+ The target object, calls to which will be intercepted.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of and types.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ Arguments of constructor of type which should be used to create a new instance of that type.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no constructor exists on type with parameters matching .
+ Thrown when constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The target object, calls to which will be intercepted.
+ Arguments of constructor of type which should be used to create a new instance of that type.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no constructor exists on type with parameters matching .
+ Thrown when constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The target object, calls to which will be intercepted.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no parameterless constructor exists on type .
+ Thrown when constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ Additional interface types. Calls to their members will be proxied as well.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of and types.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ Additional interface types. Calls to their members will be proxied as well.
+ The target object, calls to which will be intercepted.
+ The proxy generation options used to influence generated proxy type and object.
+ Arguments of constructor of type which should be used to create a new instance of that type.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of and types.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no constructor exists on type with parameters matching .
+ Thrown when constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ Additional interface types. Calls to their members will be proxied as well.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of and types.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The proxy generation options used to influence generated proxy type and object.
+ Arguments of constructor of type which should be used to create a new instance of that type.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no constructor exists on type with parameters matching .
+ Thrown when constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ Arguments of constructor of type which should be used to create a new instance of that type.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no constructor exists on type with parameters matching .
+ Thrown when constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no parameterless constructor exists on type .
+ Thrown when constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of type.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ Additional interface types. Calls to their members will be proxied as well.
+ The proxy generation options used to influence generated proxy type and object.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of and types.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no default constructor exists on type .
+ Thrown when default constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates proxy object intercepting calls to virtual members of type on newly created instance of that type with given .
+
+ Type of class which will be proxied.
+ Additional interface types. Calls to their members will be proxied as well.
+ The proxy generation options used to influence generated proxy type and object.
+ Arguments of constructor of type which should be used to create a new instance of that type.
+ The interceptors called during the invocation of proxied methods.
+
+ New object of type proxying calls to virtual members of and types.
+
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given object is a null reference (Nothing in Visual Basic).
+ Thrown when given or any of is a generic type definition.
+ Thrown when given is not a class type.
+ Thrown when no constructor exists on type with parameters matching .
+ Thrown when constructor of type throws an exception.
+
+ This method uses implementation to generate a proxy type.
+ As such caller should expect any type of exception that given implementation may throw.
+
+
+
+
+ Creates the proxy type for class proxy with given class, implementing given and using provided .
+
+ The base class for proxy type.
+ The interfaces that proxy type should implement.
+ The options for proxy generation process.
+ of proxy.
+
+
+
+ Creates the proxy type for interface proxy with target for given interface, implementing given on given and using provided .
+
+ The interface proxy type should implement.
+ The additional interfaces proxy type should implement.
+ Actual type that the proxy type will encompass.
+ The options for proxy generation process.
+ of proxy.
+
+
+
+ Creates the proxy type for interface proxy with target interface for given interface, implementing given on given and using provided .
+
+ The interface proxy type should implement.
+ The additional interfaces proxy type should implement.
+ The options for proxy generation process.
+ of proxy.
+
+
+
+ Creates the proxy type for interface proxy without target for given interface, implementing given and using provided .
+
+ The interface proxy type should implement.
+ The additional interfaces proxy type should implement.
+ The options for proxy generation process.
+ of proxy.
+
+
+
+ Gets or sets the that this log to.
+
+
+
+
+ Gets the proxy builder instance used to generate proxy types.
+
+ The proxy builder.
+
+
+
+
+
+
+
+
+
+
+
+
+ For interface proxies, this will point to the
+ on the target class
+
+
+
+
+ Handles the deserialization of proxies.
+
+
+
+
+ Resets the used for deserialization to a new scope.
+
+
+ This is useful for test cases.
+
+
+
+
+ Resets the used for deserialization to a given .
+
+ The scope to be used for deserialization.
+
+ By default, the deserialization process uses a different scope than the rest of the application, which can lead to multiple proxies
+ being generated for the same type. By explicitly setting the deserialization scope to the application's scope, this can be avoided.
+
+
+
+
+ Gets the used for deserialization.
+
+ As has no way of automatically determining the scope used by the application (and the application might use more than one scope at the same time), uses a dedicated scope instance for deserializing proxy types. This instance can be reset and set to a specific value via and .
+
+
+
+ Holds objects representing methods of class.
+
+
+
+
+ Holds objects representing methods of class.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Provides an extension point that allows proxies to choose specific interceptors on
+ a per method basis.
+
+
+
+
+ Selects the interceptors that should intercept calls to the given .
+
+ The type declaring the method to intercept.
+ The method that will be intercepted.
+ All interceptors registered with the proxy.
+ An array of interceptors to invoke upon calling the .
+
+ This method is called only once per proxy instance, upon the first call to the
+ . Either an empty array or null are valid return values to indicate
+ that no interceptor should intercept calls to the method. Although it is not advised, it is
+ legal to return other implementations than these provided in
+ .
+
+
+
+
+ Creates a new lock.
+
+
+
+
+
+ This interface should be implemented by classes
+ that are available in a bigger context, exposing
+ the container to different areas in the same application.
+
+ For example, in Web application, the (global) HttpApplication
+ subclasses should implement this interface to expose
+ the configured container
+
+
+
+
+
+ Exposes means to change target objects of proxies and invocations
+
+
+
+
+ Changes the target object () of current .
+
+ The new value of target of invocation.
+
+ Although the method takes the actual instance must be of type assignable to , otherwise an will be thrown.
+ Also while it's technically legal to pass null reference (Nothing in Visual Basic) as , for obvious reasons Dynamic Proxy will not be able to call the intercepted method on such target.
+ In this case last interceptor in the pipeline mustn't call or a will be throws.
+ Also while it's technically legal to pass proxy itself as , this would create stack overflow.
+ In this case last interceptor in the pipeline mustn't call or a will be throws.
+
+ Thrown when is not assignable to the proxied type.
+
+
+
+ Permanently changes the target object of the proxy. This does not affect target of the current invocation.
+
+ The new value of target of the proxy.
+
+ Although the method takes the actual instance must be of type assignable to proxy's target type, otherwise an will be thrown.
+ Also while it's technically legal to pass null reference (Nothing in Visual Basic) as , for obvious reasons Dynamic Proxy will not be able to call the intercepted method on such target.
+ In this case last interceptor in the pipeline mustn't call or a will be throws.
+ Also while it's technically legal to pass proxy itself as , this would create stack overflow.
+ In this case last interceptor in the pipeline mustn't call or a will be throws.
+
+ Thrown when is not assignable to the proxied type.
+
+
+
+ New interface that is going to be used by DynamicProxy 2
+
+
+
+
+ Get the proxy target (note that null is a valid target!)
+
+
+
+
+
+ Gets the interceptors for the proxy
+
+
+
+
+
+ Defines that the implementation wants a
+ in order to
+ access other components. The creator must be aware
+ that the component might (or might not) implement
+ the interface.
+
+
+ Used by Castle Project components to, for example,
+ gather logging factories
+
+
+
+
+ Increments IServiceProvider with a generic service resolution operation.
+
+
+
+
+ Provides a factory that can produce either or
+ classes.
+
+
+
+
+ Manages the instantiation of s.
+
+
+
+
+ Creates a new logger, getting the logger name from the specified type.
+
+
+
+
+ Creates a new logger.
+
+
+
+
+ Creates a new logger, getting the logger name from the specified type.
+
+
+
+
+ Creates a new logger.
+
+
+
+
+ Creates a new extended logger, getting the logger name from the specified type.
+
+
+
+
+ Creates a new extended logger.
+
+
+
+
+ Creates a new extended logger, getting the logger name from the specified type.
+
+
+
+
+ Creates a new extended logger.
+
+
+
+
+ Creates a new extended logger, getting the logger name from the specified type.
+
+
+
+
+ Creates a new extended logger.
+
+
+
+
+ Creates a new extended logger, getting the logger name from the specified type.
+
+
+
+
+ Creates a new extended logger.
+
+
+
+
+ Creates a new logger, getting the logger name from the specified type.
+
+
+
+
+ Creates a new logger.
+
+
+
+
+ Creates a new logger, getting the logger name from the specified type.
+
+
+
+
+ Creates a new logger.
+
+
+
+
+ Gets the configuration file.
+
+ i.e. log4net.config
+
+
+
+
+ Used to create the TraceLogger implementation of ILogger interface. See .
+
+
+
+
+ Gets the configuration file.
+
+ i.e. log4net.config
+
+
+
+
+ Interface for Context Properties implementations
+
+
+
+ This interface defines a basic property get set accessor.
+
+
+ Based on the ContextPropertiesBase of log4net, by Nicko Cadell.
+
+
+
+
+
+ Gets or sets the value of a property
+
+
+ The value for the property with the specified key
+
+
+
+ Gets or sets the value of a property
+
+
+
+
+
+ NullLogFactory used when logging is turned off.
+
+
+
+
+ Creates an instance of ILogger with the specified name.
+
+ Name.
+
+
+
+
+ Creates an instance of ILogger with the specified name and LoggerLevel.
+
+ Name.
+ Level.
+
+
+
+
+ Creates outputing
+ to files. The name of the file is derived from the log name
+ plus the 'log' extension.
+
+
+
+
+ Provides an interface that supports and
+ allows the storage and retrieval of Contexts. These are supported in
+ both log4net and NLog.
+
+
+
+
+ Manages logging.
+
+
+ This is a facade for the different logging subsystems.
+ It offers a simplified interface that follows IOC patterns
+ and a simplified priority/level/severity abstraction.
+
+
+
+
+ Create a new child logger.
+ The name of the child logger is [current-loggers-name].[passed-in-name]
+
+ The Subname of this logger.
+ The New ILogger instance.
+ If the name has an empty element name.
+
+
+
+ Logs a debug message.
+
+ The message to log
+
+
+
+ Logs a debug message with lazily constructed message. The message will be constructed only if the is true.
+
+
+
+
+
+ Logs a debug message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs a debug message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a debug message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a debug message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a debug message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an error message.
+
+ The message to log
+
+
+
+ Logs an error message with lazily constructed message. The message will be constructed only if the is true.
+
+
+
+
+
+ Logs an error message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs an error message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an error message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an error message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an error message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a fatal message.
+
+ The message to log
+
+
+
+ Logs a fatal message with lazily constructed message. The message will be constructed only if the is true.
+
+
+
+
+
+ Logs a fatal message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs a fatal message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a fatal message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a fatal message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a fatal message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an info message.
+
+ The message to log
+
+
+
+ Logs a info message with lazily constructed message. The message will be constructed only if the is true.
+
+
+
+
+
+ Logs an info message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs an info message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an info message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an info message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an info message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a warn message.
+
+ The message to log
+
+
+
+ Logs a warn message with lazily constructed message. The message will be constructed only if the is true.
+
+
+
+
+
+ Logs a warn message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs a warn message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a warn message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a warn message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a warn message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Determines if messages of priority "debug" will be logged.
+
+ True if "debug" messages will be logged.
+
+
+
+ Determines if messages of priority "error" will be logged.
+
+ True if "error" messages will be logged.
+
+
+
+ Determines if messages of priority "fatal" will be logged.
+
+ True if "fatal" messages will be logged.
+
+
+
+ Determines if messages of priority "info" will be logged.
+
+ True if "info" messages will be logged.
+
+
+
+ Determines if messages of priority "warn" will be logged.
+
+ True if "warn" messages will be logged.
+
+
+
+ Exposes the Global Context of the extended logger.
+
+
+
+
+ Exposes the Thread Context of the extended logger.
+
+
+
+
+ Exposes the Thread Stack of the extended logger.
+
+
+
+
+ The Logger sending everything to the standard output streams.
+ This is mainly for the cases when you have a utility that
+ does not have a logger to supply.
+
+
+
+
+ The Level Filtered Logger class. This is a base clase which
+ provides a LogLevel attribute and reroutes all functions into
+ one Log method.
+
+
+
+
+ Creates a new LevelFilteredLogger.
+
+
+
+
+ Keep the instance alive in a remoting scenario
+
+
+
+
+
+ Logs a debug message.
+
+ The message to log
+
+
+
+ Logs a debug message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs a debug message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a debug message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a debug message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a debug message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an info message.
+
+ The message to log
+
+
+
+ Logs an info message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs an info message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an info message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an info message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an info message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a warn message.
+
+ The message to log
+
+
+
+ Logs a warn message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs a warn message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a warn message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a warn message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a warn message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an error message.
+
+ The message to log
+
+
+
+ Logs an error message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs an error message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an error message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an error message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs an error message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a fatal message.
+
+ The message to log
+
+
+
+ Logs a fatal message.
+
+ The exception to log
+ The message to log
+
+
+
+ Logs a fatal message.
+
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a fatal message.
+
+ The exception to log
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a fatal message.
+
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Logs a fatal message.
+
+ The exception to log
+ The format provider to use
+ Format string for the message to log
+ Format arguments for the message to log
+
+
+
+ Implementors output the log content by implementing this method only.
+ Note that exception can be null
+
+
+
+
+
+
+
+
+ The LoggerLevel that this logger
+ will be using. Defaults to LoggerLevel.Off
+
+
+
+
+ The name that this logger will be using.
+ Defaults to String.Empty
+
+
+
+
+ Determines if messages of priority "debug" will be logged.
+
+ true if log level flags include the bit
+
+
+
+ Determines if messages of priority "info" will be logged.
+
+ true if log level flags include the bit
+
+
+
+ Determines if messages of priority "warn" will be logged.
+
+ true if log level flags include the bit
+
+
+
+ Determines if messages of priority "error" will be logged.
+
+ true if log level flags include the bit
+
+
+
+ Determines if messages of priority "fatal" will be logged.
+
+ true if log level flags include the bit
+
+
+
+ Creates a new ConsoleLogger with the Level
+ set to LoggerLevel.Debug and the Name
+ set to String.Empty.
+
+
+
+
+ Creates a new ConsoleLogger with the Name
+ set to String.Empty.
+
+ The logs Level.
+
+
+
+ Creates a new ConsoleLogger with the Level
+ set to LoggerLevel.Debug.
+
+ The logs Name.
+
+
+
+ Creates a new ConsoleLogger.
+
+ The logs Name.
+ The logs Level.
+
+
+
+ A Common method to log.
+
+ The level of logging
+ The name of the logger
+ The Message
+ The Exception
+
+
+
+ Returns a new ConsoleLogger with the name
+ added after this loggers name, with a dot in between.
+
+ The added hierarchical name.
+ A new ConsoleLogger.
+
+
+
+ The Logger using standart Diagnostics namespace.
+
+
+
+
+ Creates a logger based on .
+
+
+
+
+
+ Creates a logger based on .
+
+
+
+
+
+
+ Creates a logger based on .
+
+
+
+
+
+
+
+ The Null Logger class. This is useful for implementations where you need
+ to provide a logger to a utility class, but do not want any output from it.
+ It also helps when you have a utility that does not have a logger to supply.
+
+
+
+
+ Returns this NullLogger.
+
+ Ignored
+ This ILogger instance.
+
+
+
+ No-op.
+
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ No-op.
+
+ Ignored
+ Ignored
+ Ignored
+ Ignored
+
+
+
+ Returns empty context properties.
+
+
+
+
+ Returns empty context properties.
+
+
+
+
+ Returns empty context stacks.
+
+
+
+
+ No-op.
+
+ false
+
+
+
+ No-op.
+
+ false
+
+
+
+ No-op.
+
+ false
+
+
+
+ No-op.
+
+ false
+
+
+
+ No-op.
+
+ false
+
+
+
+ The Stream Logger class. This class can stream log information
+ to any stream, it is suitable for storing a log file to disk,
+ or to a MemoryStream for testing your components.
+
+
+ This logger is not thread safe.
+
+
+
+
+ Creates a new StreamLogger with default encoding
+ and buffer size. Initial Level is set to Debug.
+
+
+ The name of the log.
+
+
+ The stream that will be used for logging,
+ seeking while the logger is alive
+
+
+
+
+ Creates a new StreamLogger with default buffer size.
+ Initial Level is set to Debug.
+
+
+ The name of the log.
+
+
+ The stream that will be used for logging,
+ seeking while the logger is alive
+
+
+ The encoding that will be used for this stream.
+
+
+
+
+
+ Creates a new StreamLogger.
+ Initial Level is set to Debug.
+
+
+ The name of the log.
+
+
+ The stream that will be used for logging,
+ seeking while the logger is alive
+
+
+ The encoding that will be used for this stream.
+
+
+
+ The buffer size that will be used for this stream.
+
+
+
+
+
+ Creates a new StreamLogger with
+ Debug as default Level.
+
+ The name of the log.
+ The StreamWriter the log will write to.
+
+
+
+ The TraceLogger sends all logging to the System.Diagnostics.TraceSource
+ built into the .net framework.
+
+
+ Logging can be configured in the system.diagnostics configuration
+ section.
+
+ If logger doesn't find a source name with a full match it will
+ use source names which match the namespace partially. For example you can
+ configure from all castle components by adding a source name with the
+ name "Castle".
+
+ If no portion of the namespace matches the source named "Default" will
+ be used.
+
+
+
+
+ Build a new trace logger based on the named TraceSource
+
+ The name used to locate the best TraceSource. In most cases comes from the using type's fullname.
+
+
+
+ Build a new trace logger based on the named TraceSource
+
+ The name used to locate the best TraceSource. In most cases comes from the using type's fullname.
+ The default logging level at which this source should write messages. In almost all cases this
+ default value will be overridden in the config file.
+
+
+
+ Create a new child logger.
+ The name of the child logger is [current-loggers-name].[passed-in-name]
+
+ The Subname of this logger.
+ The New ILogger instance.
+
+
+
+ This is an abstract implementation
+ that deals with methods that can be abstracted away
+ from underlying implementations.
+
+
+ AbstractConfiguration makes easier to implementers
+ to create a new version of
+
+
+
+
+ is a interface encapsulating a configuration node
+ used to retrieve configuration values.
+
+
+
+
+ Gets the value of the node and converts it
+ into specified .
+
+ The
+
+ The Default value returned if the conversion fails.
+
+ The Value converted into the specified type.
+
+
+
+ Gets the name of the node.
+
+
+ The Name of the node.
+
+
+
+
+ Gets the value of the node.
+
+
+ The Value of the node.
+
+
+
+
+ Gets an of
+ elements containing all node children.
+
+ The Collection of child nodes.
+
+
+
+ Gets an of the configuration attributes.
+
+
+
+
+ Gets the value of the node and converts it
+ into specified .
+
+ The
+
+ The Default value returned if the conversion fails.
+
+ The Value converted into the specified type.
+
+
+
+ Gets node attributes.
+
+
+ All attributes of the node.
+
+
+
+
+ Gets all child nodes.
+
+ The of child nodes.
+
+
+
+ Gets the name of the .
+
+
+ The Name of the .
+
+
+
+
+ Gets the value of .
+
+
+ The Value of the .
+
+
+
+
+ A collection of objects.
+
+
+
+
+ Creates a new instance of ConfigurationCollection.
+
+
+
+
+ Creates a new instance of ConfigurationCollection.
+
+
+
+
+ Summary description for MutableConfiguration.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The name.
+
+
+
+ Gets the value of .
+
+
+ The Value of the .
+
+
+
+
+ Deserializes the specified node into an abstract representation of configuration.
+
+ The node.
+
+
+
+
+ If a config value is an empty string we return null, this is to keep
+ backward compatibility with old code
+
+
+
+
+ General purpose class to represent a standard pair of values.
+
+ Type of the first value
+ Type of the second value
+
+
+
+ Constructs a pair with its values
+
+
+
+
+
+
+ List of utility methods related to dynamic proxy operations
+
+
+
+
+ Determines whether the specified type is a proxy generated by
+ DynamicProxy (1 or 2).
+
+ The type.
+
+ true if it is a proxy; otherwise, false.
+
+
+
+
+ Readonly implementation of which uses an anonymous object as its source. Uses names of properties as keys, and property values as... well - values. Keys are not case sensitive.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The target.
+
+
+
+ Adds an element with the provided key and value to the object.
+
+ The to use as the key of the element to add.
+ The to use as the value of the element to add.
+
+ is null.
+ An element with the same key already exists in the object.
+ The is read-only.-or- The has a fixed size.
+
+
+
+ Removes all elements from the object.
+
+ The object is read-only.
+
+
+
+ Determines whether the object contains an element with the specified key.
+
+ The key to locate in the object.
+
+ true if the contains an element with the key; otherwise, false.
+
+
+ is null.
+
+
+
+ Removes the element with the specified key from the object.
+
+ The key of the element to remove.
+
+ is null.
+ The object is read-only.-or- The has a fixed size.
+
+
+
+ Returns an enumerator that iterates through a collection.
+
+
+ An object that can be used to iterate through the collection.
+
+
+
+
+ Copies the elements of the to an , starting at a particular index.
+
+ The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing.
+ The zero-based index in at which copying begins.
+
+ is null.
+
+ is less than zero.
+
+ is multidimensional.-or- is equal to or greater than the length of .-or- The number of elements in the source is greater than the available space from to the end of the destination .
+ The type of the source cannot be cast automatically to the type of the destination .
+
+
+
+ Returns an object for the object.
+
+
+ An object for the object.
+
+
+
+
+ Reads values of properties from and inserts them into using property names as keys.
+
+
+
+
+
+
+ Gets the number of elements contained in the .
+
+
+ The number of elements contained in the .
+
+
+
+ Gets a value indicating whether access to the is synchronized (thread safe).
+
+
+ true if access to the is synchronized (thread safe); otherwise, false.
+
+
+
+ Gets an object that can be used to synchronize access to the .
+
+
+ An object that can be used to synchronize access to the .
+
+
+
+ Gets a value indicating whether the object is read-only.
+
+
+ true if the object is read-only; otherwise, false.
+
+
+
+ Gets or sets the with the specified key.
+
+
+
+
+
+ Gets an object containing the keys of the object.
+
+
+ An object containing the keys of the object.
+
+
+
+ Gets an object containing the values in the object.
+
+
+ An object containing the values in the object.
+
+
+
+ Gets a value indicating whether the object has a fixed size.
+
+
+ true if the object has a fixed size; otherwise, false.
+
+
+
+ Represents a 'streamable' resource. Can
+ be a file, a resource in an assembly.
+
+
+
+
+ Returns a reader for the stream
+
+
+ It's up to the caller to dispose the reader.
+
+
+
+
+
+ Returns a reader for the stream
+
+
+ It's up to the caller to dispose the reader.
+
+
+
+
+
+
+ Returns an instance of
+ created according to the relativePath
+ using itself as the root.
+
+
+
+
+
+
+
+
+
+ Only valid for resources that
+ can be obtained through relative paths
+
+
+
+
+
+
+
+
+
+ This returns a new stream instance each time it is called.
+ It is the responsibility of the caller to dispose of this stream
+
+
+
+
+ Depicts the contract for resource factories.
+
+
+
+
+ Used to check whether the resource factory
+ is able to deal with the given resource
+ identifier.
+
+
+ Implementors should return true
+ only if the given identifier is supported
+ by the resource factory
+
+
+
+
+
+
+ Creates an instance
+ for the given resource identifier
+
+
+
+
+
+
+ Creates an instance
+ for the given resource identifier
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Adapts a static string content as an
+
+
+
+
+ Enable access to files on network shares
+
+
+
+
+ Email sender abstraction.
+
+
+
+
+ Sends a mail message.
+
+ From field
+ To field
+ E-mail's subject
+ message's body
+
+
+
+ Sends a message.
+
+ Message instance
+
+
+
+ Sends multiple messages.
+
+ List of messages
+
+
+
+ Default implementation.
+
+
+
+
+ Initializes a new instance of the class based on the configuration provided in the application configuration file.
+
+
+ This constructor is based on the default configuration in the application configuration file.
+
+
+
+
+ This service implementation
+ requires a host name in order to work
+
+ The smtp server name
+
+
+
+ Sends a message.
+
+ If any of the parameters is null
+ From field
+ To field
+ e-mail's subject
+ message's body
+
+
+
+ Sends a message.
+
+ If the message is null
+ Message instance
+
+
+
+ Configures the sender
+ with port information and eventual credential
+ informed
+
+ Message instance
+
+
+
+ Gets or sets the port used to
+ access the SMTP server
+
+
+
+
+ Gets the hostname.
+
+ The hostname.
+
+
+
+ Gets or sets a value which is used to
+ configure if emails are going to be sent asynchronously or not.
+
+
+
+
+ Gets or sets a value that specifies
+ the amount of time after which a synchronous Send call times out.
+
+
+
+
+ Gets or sets a value indicating whether the email should be sent using
+ a secure communication channel.
+
+ true if should use SSL; otherwise, false.
+
+
+
+ Gets or sets the domain.
+
+ The domain.
+
+
+
+ Gets or sets the name of the user.
+
+ The name of the user.
+
+
+
+ Gets or sets the password.
+
+ The password.
+
+
+
+ Gets a value indicating whether credentials were informed.
+
+
+ if this instance has credentials; otherwise, .
+
+
+
+
diff --git a/nuspec/ReadMe.txt b/nuspec/ReadMe.txt
index 82b9a36..3d9ea91 100644
--- a/nuspec/ReadMe.txt
+++ b/nuspec/ReadMe.txt
@@ -7,4 +7,7 @@ Issue tracker: - https://github.com/boxes-project/Windsor/issues
StackOverflow tags: - boxes
-Any help with the documentation, providing examples would be epic.
\ No newline at end of file
+Any help with the documentation, providing examples would be epic.
+
+
+Upgrading from 0.2.x - please checkout the documentation.
\ No newline at end of file
diff --git a/nuspec/changes.txt b/nuspec/changes.txt
index ea8dd17..547d871 100644
--- a/nuspec/changes.txt
+++ b/nuspec/changes.txt
@@ -1,3 +1,7 @@
+0.4.x
+==============
+AOP support
+
0.3.x
==============
updated to support the 0.3.x changes made in integration
diff --git a/src/Boxes.Windsor/RegistrationTask.cs b/src/Boxes.Windsor/RegistrationTask.cs
index 3992883..ae08ab8 100644
--- a/src/Boxes.Windsor/RegistrationTask.cs
+++ b/src/Boxes.Windsor/RegistrationTask.cs
@@ -14,20 +14,24 @@
namespace Boxes.Windsor
{
using System;
+ using System.Linq;
using Castle.MicroKernel.Registration;
using Castle.Windsor;
using Integration.Setup;
+ using Integration.Setup.Interception;
using Tasks;
internal class RegistrationTask : IBoxesTask>
{
private readonly RegistrationMeta _registration;
+ private readonly IInterceptionSelector _interceptionSelector;
- public RegistrationTask( RegistrationMeta registration)
+ public RegistrationTask(RegistrationMeta registration, IInterceptionSelector interceptionSelector)
{
_registration = registration;
+ _interceptionSelector = interceptionSelector;
}
-
+
public bool CanHandle(RegistrationContext item)
{
return _registration.Where(item.Type);
@@ -36,7 +40,7 @@ public bool CanHandle(RegistrationContext item)
public void Execute(RegistrationContext item)
{
var typeToRegister = item.Type;
- var interfaces = _registration.With(typeToRegister);
+ var interfaces = _registration.With(typeToRegister).ToList();
var reg = Component.For(interfaces).ImplementedBy(typeToRegister).LifestyleCustom((Type)_registration.LifeStyle);
if (_registration.FactoryMethod != null)
@@ -44,6 +48,9 @@ public void Execute(RegistrationContext item)
reg.UsingFactoryMethod(kernal => _registration.FactoryMethod);
}
+ var interceptorContext = new InterceptionContext() { Contracts = interfaces, Service = typeToRegister };
+ reg.Interceptors(_interceptionSelector.InterceptorsToApply(interceptorContext).ToArray());
+
foreach (var configuraition in _registration.Configurations)
{
Action