Microsoft.Practices.Unity

Base class for attributes that can be placed on parameters or properties to specify how to resolve the value for that parameter or property.

Create an instance of that will be used to get the value for the member this attribute is applied to.

Type of parameter or property that this attribute is decoration. The resolver object.

This attribute is used to indicate which constructor to choose when the container attempts to build a type.

This attribute is used to mark methods that should be called when the container is building an object.

This attribute is used to mark properties and parameters as targets for injection.

For properties, this attribute is necessary for injection to happen. For parameters, it's not needed unless you want to specify additional information to control how the parameter is resolved.

Create an instance of with no name.

Create an instance of with the given name.

Name to use when resolving this dependency.

Create an instance of that will be used to get the value for the member this attribute is applied to.

Type of parameter or property that this attribute is decoration. The resolver object.

The name specified in the constructor.

An used to mark a dependency as optional - the container will try to resolve it, and return null if the resolution fails rather than throw.

Construct a new object.

Construct a new object that specifies a named dependency.

Name of the dependency.

Create an instance of that will be used to get the value for the member this attribute is applied to.

Type of parameter or property that this attribute is decoration. The resolver object.

Name of the dependency.

A that composites other ResolverOverride objects. The GetResolver operation then returns the resolver from the first child override that matches the current context and request.

Base class for all override objects passed in the method.

Return a that can be used to give a value for the given desired dependency.

Current build context. Type of dependency desired. a object if this override applies, null if not.

Wrap this resolver in one that verifies the type of the object being built. This allows you to narrow any override down to a specific type easily.

Type to constrain the override to. The new override.

Wrap this resolver in one that verifies the type of the object being built. This allows you to narrow any override down to a specific type easily.

Type to constrain the override to. The new override.

Add a new to the collection that is checked.

item to add.

Add a setof s to the collection.

items to add.

Returns an enumerator that iterates through a collection.

An object that can be used to iterate through the collection. 2

Returns an enumerator that iterates through the collection.

A that can be used to iterate through the collection. 1

Return a that can be used to give a value for the given desired dependency.

Current build context. Type of dependency desired. a object if this override applies, null if not.

Class that returns information about the types registered in a container.

The type that was passed to the method as the "from" type, or the only type if type mapping wasn't done.

The type that this registration is mapped to. If no type mapping was done, the property and this one will have the same value.

Name the type was registered under. Null for default registration.

The registered lifetime manager instance.

The lifetime manager for this registration.

This property will be null if this registration is for an open generic.

A class that overrides the value injected whenever there is a dependency of the given type, regardless of where it appears in the object graph.

Create an instance of to override the given type with the given value.

Type of the dependency. Value to use.

Return a that can be used to give a value for the given desired dependency.

Current build context. Type of dependency desired. a object if this override applies, null if not.

A convenience version of that lets you specify the dependency type using generic syntax.

Type of the dependency to override.

Construct a new object that will override the given dependency, and pass the given value.

A convenience form of that lets you specify multiple parameter overrides in one shot rather than having to construct multiple objects.

This class isn't really a collection, it just implements IEnumerable so that we get use of the nice C# collection initializer syntax.

Base helper class for creating collections of objects for use in passing a bunch of them to the resolve call. This base class provides the mechanics needed to allow you to use the C# collection initializer syntax.

Concrete type of the this class collects. Key used to create the underlying override object. Value that the override returns.

Add a new override to the collection with the given key and value.

Key - for example, a parameter or property name. Value - the value to be returned by the override.

Return a that can be used to give a value for the given desired dependency.

Current build context. Type of dependency desired. a object if this override applies, null if not.

Returns an enumerator that iterates through a collection.

An object that can be used to iterate through the collection. 2

Returns an enumerator that iterates through the collection.

A that can be used to iterate through the collection. 1

When implemented in derived classes, this method is called from the method to create the actual objects.

Key value to create the resolver. Value to store in the resolver. The created .

When implemented in derived classes, this method is called from the method to create the actual objects.

Key value to create the resolver. Value to store in the resolver. The created .

Event argument class for the event.

Construct a new object with the given child container object.

An for the newly created child container.

The newly created child container.

An extension context for the created child container.

Base class for subclasses that let you specify that an instance of a generic type parameter should be resolved.

Base type for objects that are used to configure parameters for constructor or method injection, or for getting the value to be injected into a property.

Test to see if this parameter value has a matching type for the given type.

Type to check. True if this parameter value is compatible with type , false if not.

Return a instance that will return this types value for the parameter.

Type that contains the member that needs this parameter. Used to resolve open generic parameters. The .

Convert the given set of arbitrary values to a sequence of InjectionParameterValue objects. The rules are: If it's already an InjectionParameterValue, return it. If it's a Type, return a ResolvedParameter object for that type. Otherwise return an InjectionParameter object for that value.

The values to build the sequence from. The resulting converted sequence.

Convert an arbitrary value to an InjectionParameterValue object. The rules are: If it's already an InjectionParameterValue, return it. If it's a Type, return a ResolvedParameter object for that type. Otherwise return an InjectionParameter object for that value.

The value to convert. The resulting .

Name for the type represented by this . This may be an actual type name or a generic argument name.

Create a new instance that specifies that the given named generic parameter should be resolved.

The generic parameter name to resolve.

Create a new instance that specifies that the given named generic parameter should be resolved.

The generic parameter name to resolve. name to use when looking up in the container.

Test to see if this parameter value has a matching type for the given type.

Type to check. True if this parameter value is compatible with type , false if not.

Return a instance that will return this types value for the parameter.

Type that contains the member that needs this parameter. Used to resolve open generic parameters. The .

Return a instance that will return this types value for the parameter.

The actual type to resolve. The resolution key. The .

Name for the type represented by this . This may be an actual type name or a generic argument name.

A that lets you specify that an instance of a generic type parameter should be resolved, providing the value if resolving fails.

Create a new instance that specifies that the given named generic parameter should be resolved.

The generic parameter name to resolve.

Create a new instance that specifies that the given named generic parameter should be resolved.

The generic parameter name to resolve. name to use when looking up in the container.

Return a instance that will return this types value for the parameter.

The actual type to resolve. The resolution key. The .

A class that lets you specify a factory method the container will use to create the object.

This is a significantly easier way to do the same thing the old static factory extension was used for.

Base class for objects that can be used to configure what class members get injected by the container.

Add policies to the to configure the container to call this constructor with the appropriate parameter values.

Type to register. Policy list to add policies to.

Add policies to the to configure the container to call this constructor with the appropriate parameter values.

Type of interface being registered. If no interface, this will be null. Type of concrete type being registered. Name used to resolve the type object. Policy list to add policies to.

Create a new instance of with the given factory function.

Factory function.

Create a new instance of with the given factory function.

Factory function.

Add policies to the to configure the container to call this constructor with the appropriate parameter values.

Type of interface being registered. If no interface, this will be null. This parameter is ignored in this implementation. Type of concrete type being registered. Name used to resolve the type object. Policy list to add policies to.

A that can be passed to to configure a parameter or property as an optional dependency.

A base class for implementing classes that deal in explicit types.

Create a new that exposes information about the given .

Type of the parameter.

Test to see if this parameter value has a matching type for the given type.

Type to check. True if this parameter value is compatible with type , false if not.

The type of parameter this object represents.

Name for the type represented by this . This may be an actual type name or a generic argument name.

Construct a new object that specifies the given .

Type of the dependency.

Construct a new object that specifies the given and .

Type of the dependency. Name for the dependency.

Return a instance that will return this types value for the parameter.

Type that contains the member that needs this parameter. Used to resolve open generic parameters. The .

A generic version of that lets you specify the type of the dependency using generics syntax.

Type of the dependency.

Construct a new .

Construct a new with the given .

Name of the dependency.

A special lifetime manager which works like , except that in the presence of child containers, each child gets it's own instance of the object, instead of sharing one in the common parent.

A that holds onto the instance given to it. When the is disposed, the instance is disposed with it.

Base class for Lifetime managers which need to synchronize calls to .

The purpose of this class is to provide a basic implementation of the lifetime manager synchronization pattern. Calls to the method of a instance acquire a lock, and if the instance has not been initialized with a value yet the lock will only be released when such an initialization takes place by calling the method or if the build request which resulted in the call to the GetValue method fails.

Base class for Lifetime managers - classes that control how and when instances are created by the Unity container.

A that controls how instances are persisted and recovered from an external store. Used to implement things like singletons and per-http-request lifetime.

Represents a builder policy interface. Since there are no fixed requirements for policies, it acts as a marker interface from which to derive all other policy interfaces.

Retrieve a value from the backing store associated with this Lifetime policy.

the object desired, or null if no such object is currently stored.

Stores the given value into backing store for retrieval later.

The object to store.

Remove the value this lifetime policy is managing from backing store.

Retrieve a value from the backing store associated with this Lifetime policy.

the object desired, or null if no such object is currently stored.

Stores the given value into backing store for retrieval later.

The object being stored.

Remove the given object from backing store.

This interface provides a hook for the builder context to implement error recovery when a builder strategy throws an exception. Since we can't get try/finally blocks onto the call stack for later stages in the chain, we instead add these objects to the context. If there's an exception, all the current IRequiresRecovery instances will have their Recover methods called.

A method that does whatever is needed to clean up as part of cleaning up after an exception.

Don't do anything that could throw in this method, it will cause later recover operations to get skipped and play real havoc with the stack trace.

Retrieve a value from the backing store associated with this Lifetime policy.

the object desired, or null if no such object is currently stored. Calls to this method acquire a lock which is released only if a non-null value has been set for the lifetime manager.

Performs the actual retrieval of a value from the backing store associated with this Lifetime policy.

the object desired, or null if no such object is currently stored. This method is invoked by after it has acquired its lock.

Stores the given value into backing store for retrieval later.

The object being stored. Setting a value will attempt to release the lock acquired by .

Performs the actual storage of the given value into backing store for retrieval later.

The object being stored. This method is invoked by before releasing its lock.

Remove the given object from backing store.

A method that does whatever is needed to clean up as part of cleaning up after an exception.

Don't do anything that could throw in this method, it will cause later recover operations to get skipped and play real havoc with the stack trace.

Retrieve a value from the backing store associated with this Lifetime policy.

the object desired, or null if no such object is currently stored.

Stores the given value into backing store for retrieval later.

The object being stored.

Remove the given object from backing store.

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Standard Dispose pattern implementation. Not needed, but it keeps FxCop happy.

Always true, since we don't have a finalizer.

This is a custom lifetime manager that acts like , but also provides a signal to the default build plan, marking the type so that instances are reused across the build up object graph.

Construct a new object that does not itself manage an instance.

Construct a new object that stores the give value. This value will be returned by but is not stored in the lifetime manager, nor is the value disposed. This Lifetime manager is intended only for internal use, which is why the normal method is not used here.

Value to store.

Retrieve a value from the backing store associated with this Lifetime policy.

the object desired, or null if no such object is currently stored.

Stores the given value into backing store for retrieval later. In this class, this is a noop, since it has special hooks down in the guts.

The object being stored.

Remove the given object from backing store. Noop in this class.

A strategy that handles Hierarchical lifetimes across a set of parent/child containers.

Represents a strategy in the chain of responsibility. Strategies are required to support both BuildUp and TearDown.

Represents a strategy in the chain of responsibility. Strategies are required to support both BuildUp and TearDown. Although you can implement this interface directly, you may also choose to use as the base class for your strategies, as this class provides useful helper methods and makes support BuildUp and TearDown optional.

Called during the chain of responsibility for a build operation. The PreBuildUp method is called when the chain is being executed in the forward direction.

Context of the build operation.

Called during the chain of responsibility for a build operation. The PostBuildUp method is called when the chain has finished the PreBuildUp phase and executes in reverse order from the PreBuildUp calls.

Context of the build operation.

Called during the chain of responsibility for a teardown operation. The PreTearDown method is called when the chain is being executed in the forward direction.

Context of the teardown operation.

Called during the chain of responsibility for a teardown operation. The PostTearDown method is called when the chain has finished the PreTearDown phase and executes in reverse order from the PreTearDown calls.

Context of the teardown operation.

Called during the chain of responsibility for a build operation. The PreBuildUp method is called when the chain is being executed in the forward direction.

Context of the build operation.

Called during the chain of responsibility for a teardown operation. The PreTearDown method is called when the chain is being executed in the forward direction.

Context of the teardown operation.

Called during the chain of responsibility for a build operation. The PreBuildUp method is called when the chain is being executed in the forward direction.

Context of the build operation.

A that will attempt to resolve a value, and return null if it cannot rather than throwing.

A that is used at build plan execution time to resolve a dependent value.

Get the value for a dependency.

Current build context. The value for the dependency.

Construct a new object that will attempt to resolve the given name and type from the container.

Type to resolve. Must be a reference type. Name to resolve with.

Construct a new object that will attempt to resolve the given type from the container.

Type to resolve. Must be a reference type.

Get the value for a dependency.

Current build context. The value for the dependency.

Type this resolver will resolve.

Name this resolver will resolve.

Extension methods on to provide convenience overloads (generic versions, mostly).

Removes an individual policy type for a build key.

The type the policy was registered as. to remove the policy from. The key the policy applies.

Removes a default policy.

The type the policy was registered as. to remove the policy from.

Gets an individual policy.

The interface the policy is registered under. to search. The key the policy applies. The policy in the list, if present; returns null otherwise.

Gets an individual policy.

The interface the policy is registered under. to search. The key the policy applies. The policy list that actually contains the returned policy. The policy in the list, if present; returns null otherwise.

Gets an individual policy.

to search. The interface the policy is registered under. The key the policy applies. The policy in the list, if present; returns null otherwise.

Gets an individual policy.

to search. The interface the policy is registered under. The key the policy applies. The policy list that actually contains the returned policy. The policy in the list, if present; returns null otherwise.

Gets an individual policy.

The interface the policy is registered under. to search. The key the policy applies. true if the policy searches local only; otherwise false to seach up the parent chain. The policy in the list, if present; returns null otherwise.

Gets an individual policy.

to search. The interface the policy is registered under. The key the policy applies. true if the policy searches local only; otherwise false to seach up the parent chain. The policy in the list, if present; returns null otherwise.

Get the non default policy.

Sets an individual policy.

The interface the policy is registered under. to add the policy to. The policy to be registered. The key the policy applies.

Sets a default policy. When checking for a policy, if no specific individual policy is available, the default will be used.

The interface to register the policy under. to add the policy to. The default policy to be registered.

Base class for the current operation stored in the build context.

Create a new .

Type currently being built.

The type that's currently being built.

Build plan for that will return a func that will resolve the requested type through this container later.

A build plan is an object that, when invoked, will create a new object or fill in a given existing one. It encapsulates all the information gathered by the strategies to construct a particular object.

Creates an instance of this build plan's type, or fills in the existing type if passed in.

Context used to build up the object.

Creates an instance of this build plan's type, or fills in the existing type if passed in.

Context used to build up the object.

The almost inevitable collection of extra helper methods on to augment the rich set of what Linq already gives us.

Execute the provided on every item in .

Type of the items stored in Sequence of items to process. Code to run over each item.

Create a single string from a sequenc of items, separated by the provided , and with the conversion to string done by the given .

This method does basically the same thing as , but will work on any sequence of items, not just arrays. Type of items in the sequence. Sequence of items to convert. Separator to place between the items in the string. The conversion function to change TItem -> string. The resulting string.

Create a single string from a sequenc of items, separated by the provided , and with the conversion to string done by the item's method.

A class that lets you override a named parameter passed to a constructor.

Construct a new object that will override the given named constructor parameter, and pass the given value.

Name of the constructor parameter. Value to pass for the constructor.

Return a that can be used to give a value for the given desired dependency.

Current build context. Type of dependency desired. a object if this override applies, null if not.

A convenience form of that lets you specify multiple parameter overrides in one shot rather than having to construct multiple objects.

When implemented in derived classes, this method is called from the method to create the actual objects.

Key value to create the resolver. Value to store in the resolver. The created .

A that lets you override the value for a specified property.

Create an instance of .

The property name. Value to use for the property.

Return a that can be used to give a value for the given desired dependency.

Current build context. Type of dependency desired. a object if this override applies, null if not.

A convenience form of that lets you specify multiple property overrides in one shot rather than having to construct multiple objects.

When implemented in derived classes, this method is called from the method to create the actual objects.

Key value to create the resolver. Value to store in the resolver. The created .

Interface defining the configuration interface exposed by the Static Factory extension.

Base interface for all extension configuration interfaces.

Retrieve the container instance that we are currently configuring.

Type that will be requested from the container. Delegate to invoke to create the instance. The container extension object this method was invoked on.

Type that will be requested from the container. The name that will be used when requesting to resolve this type. Delegate to invoke to create the instance. The container extension object this method was invoked on.

Represents the context in which a build-up or tear-down operation runs.

Add a new set of resolver override objects to the current build operation.

objects to add.

Get a object for the given or null if that dependency hasn't been overridden.

Type of the dependency. Resolver to use, or null if no override matches for the current operation.

A convenience method to do a new buildup operation on an existing context.

Key to use to build up. Created object.

A convenience method to do a new buildup operation on an existing context. This overload allows you to specify extra policies which will be in effect for the duration of the build.

Key defining what to build up. A delegate that takes a . This is invoked with the new child context before the build up process starts. This gives callers the opportunity to customize the context for the build process. Created object.

Gets the head of the strategy chain.

The strategy that's first in the chain; returns null if there are no strategies in the chain.

Gets the associated with the build.

The associated with the build.

Gets the original build key for the build operation.

The original build key for the build operation.

Get the current build key for the current build operation.

The set of policies that were passed into this context.

This returns the policies passed into the context. Policies added here will remain after buildup completes. The persistent policies for the current context.

Gets the policies for the current context.

Any policies added to this object are transient and will be erased at the end of the buildup. The policies for the current context.

Gets the collection of objects that need to execute in event of an exception.

The current object being built up or torn down.

The current object being manipulated by the build operation. May be null if the object hasn't been created yet.

Flag indicating if the build operation should continue.

true means that building should not call any more strategies, false means continue to the next strategy.

An object representing what is currently being done in the build chain. Used to report back errors if there's a failure.

The build context used to resolve a dependency during the build operation represented by this context.

Initialize a new instance of the class.

Initialize a new instance of the class with a , , and the build key used to start this build operation.

The to use for this context. The to use for this context. The to use for this context. Build key to start building. The existing object to build up.

Create a new using the explicitly provided values.

The to use for this context. The to use for this context. The set of persistent policies to use for this context. The set of transient policies to use for this context. It is the caller's responsibility to ensure that the transient and persistent policies are properly combined. Build key for this context. Existing object to build up.

Add a new set of resolver override objects to the current build operation.

objects to add.

Get a object for the given or null if that dependency hasn't been overridden.

Type of the dependency. Resolver to use, or null if no override matches for the current operation.

A convenience method to do a new buildup operation on an existing context.

Key to use to build up. Created object.

A convenience method to do a new buildup operation on an existing context. This overload allows you to specify extra policies which will be in effect for the duration of the build.

Gets the head of the strategy chain.

The strategy that's first in the chain; returns null if there are no strategies in the chain.

Get the current build key for the current build operation.

The current object being built up or torn down.

The current object being manipulated by the build operation. May be null if the object hasn't been created yet.

Gets the associated with the build.

The associated with the build.

Gets the original build key for the build operation.

The original build key for the build operation.

The set of policies that were passed into this context.

This returns the policies passed into the context. Policies added here will remain after buildup completes. The persistent policies for the current context.

Gets the policies for the current context.

Any modifications will be transient (meaning, they will be forgotten when the outer BuildUp for this context is finished executing). The policies for the current context.

Gets the collection of objects that need to execute in event of an exception.

Flag indicating if the build operation should continue.

true means that building should not call any more strategies, false means continue to the next strategy.

An object representing what is currently being done in the build chain. Used to report back errors if there's a failure.

The build context used to resolve a dependency during the build operation represented by this context.

Represents that a dependency could not be resolved.

Initializes a new instance of the class with no extra information.

Initializes a new instance of the class with the given message.

Some random message.

Initialize a new instance of the class with the given message and inner exception.

Some random message Inner exception.

Initializes a new instance of the class with the build key of the object begin built.

The build key of the object begin built.

Initializes a new instance of the class with serialized data.

The that holds the serialized object data about the exception being thrown. The that contains contextual information about the source or destination.

The exception thrown when injection is attempted on a method that is an open generic or has out or ref params.

Construct a new with no message.

Construct a with the given message

Message to return.

Construct a with the given message and inner exception.

Message to return. Inner exception

Used for serialization.

Serialization info. Serialization context.

Extension methods to provide convenience overloads over the interface.

Start a recursive build up operation to retrieve the default value for the given type.

Type of object to build. Parent context. Resulting object.

Start a recursive build up operation to retrieve the named implementation for the given type.

Type to resolve. Parent context. Name to resolve with. The resulting object.

Add a set of s to the context, specified as a variable argument list.

Context to add overrides to. The overrides.

Data structure that stores the set of objects and executes them when requested.

Add a new object to this list.

Object to add.

Execute the method of everything in the recovery list. Recoveries will execute in the opposite order of add - it's a stack.

Return the number of recovery objects currently in the stack.

Represents a lifetime container.

A lifetime container tracks the lifetime of an object, and implements IDisposable. When the container is disposed, any objects in the container which implement IDisposable are also disposed.

Adds an object to the lifetime container.

The item to be added to the lifetime container.

Determine if a given object is in the lifetime container.

The item to locate in the lifetime container. Returns true if the object is contained in the lifetime container; returns false otherwise.

Removes an item from the lifetime container. The item is not disposed.

The item to be removed.

Gets the number of references in the lifetime container

The number of references in the lifetime container

Represents a lifetime container.

A lifetime container tracks the lifetime of an object, and implements IDisposable. When the container is disposed, any objects in the container which implement IDisposable are also disposed.

Adds an object to the lifetime container.

The item to be added to the lifetime container.

Determine if a given object is in the lifetime container.

The item to locate in the lifetime container. Returns true if the object is contained in the lifetime container; returns false otherwise.

Releases the resources used by the .

Releases the managed resources used by the DbDataReader and optionally releases the unmanaged resources.

true to release managed and unmanaged resources; false to release only unmanaged resources.

Returns an enumerator that iterates through the lifetime container.

An object that can be used to iterate through the life time container.

Returns an enumerator that iterates through the lifetime container.

An object that can be used to iterate through the life time container.

Removes an item from the lifetime container. The item is not disposed.

The item to be removed.

Gets the number of references in the lifetime container

The number of references in the lifetime container

A custom collection over objects.

Removes an individual policy type for a build key.

The type of policy to remove. The key the policy applies.

Removes all policies from the list.

Removes a default policy.

The type the policy was registered as.

Gets an individual policy.

The interface the policy is registered under. The key the policy applies. true if the policy searches local only; otherwise false to seach up the parent chain. The policy list in the chain that the searched for policy was found in, null if the policy was not found. The policy in the list, if present; returns null otherwise.

Get the non default policy.

The interface the policy is registered under. The key the policy applies to. True if the search should be in the local policy list only; otherwise false to search up the parent chain. The policy list in the chain that the searched for policy was found in, null if the policy was not found. The policy in the list if present; returns null otherwise.

Sets an individual policy.

The of the policy. The policy to be registered. The key the policy applies.

Sets a default policy. When checking for a policy, if no specific individual policy is available, the default will be used.

The interface to register the policy under. The default policy to be registered.

A custom collection wrapper over objects.

Initialize a new instance of a class.

Initialize a new instance of a class with another policy list.

An inner policy list to search.

Removes an individual policy type for a build key.

The type of policy to remove. The key the policy applies.

Removes all policies from the list.

Removes a default policy.

The type the policy was registered as.

Gets an individual policy.

Get the non default policy.

Sets an individual policy.

The of the policy. The policy to be registered. The key the policy applies.

Sets a default policy. When checking for a policy, if no specific individual policy is available, the default will be used.

The interface to register the policy under. The default policy to be registered.

Gets the number of items in the locator.

The number of items in the locator.

An implementation of .

Add a new object to this list.

Object to add.

Execute the method of everything in the recovery list. Recoveries will execute in the opposite order of add - it's a stack.

Return the number of recovery objects currently in the stack.

Implementation of which will notify an object about the completion of a BuildUp operation, or start of a TearDown operation.

This strategy checks the object that is passing through the builder chain to see if it implements IBuilderAware and if it does, it will call and . This strategy is meant to be used from the stage.

Called during the chain of responsibility for a build operation. The PreBuildUp method is called when the chain is being executed in the forward direction.

Context of the build operation.

Called during the chain of responsibility for a teardown operation. The PreTearDown method is called when the chain is being executed in the forward direction.

Context of the teardown operation.

Implemented on a class when it wants to receive notifications about the build process.

Called by the when the object is being built up.

The key of the object that was just built up.

Called by the when the object is being torn down.

Enumeration to represent the object builder stages.

The order of the values in the enumeration is the order in which the stages are run.

Strategies in this stage run before creation. Typical work done in this stage might include strategies that use reflection to set policies into the context that other strategies would later use.

Strategies in this stage create objects. Typically you will only have a single policy-driven creation strategy in this stage.

Strategies in this stage work on created objects. Typical work done in this stage might include setter injection and method calls.

Strategies in this stage work on objects that are already initialized. Typical work done in this stage might include looking to see if the object implements some notification interface to discover when its initialization stage has been completed.

Represents a builder policy for mapping build keys.

Maps the build key.

The build key to map. Current build context. Used for contextual information if writing a more sophisticated mapping. This parameter can be null (called when getting container registrations). The new build key.

Initialize a new instance of the with the new build key.

The new build key.

Maps the build key.

The build key to map. Current build context. Used for contextual information if writing a more sophisticated mapping, unused in this implementation. The new build key.

Represents a strategy for mapping build keys in the build up operation.

Called during the chain of responsibility for a build operation. Looks for the and if found maps the build key for the current operation.

The context for the operation.

An implementation of that can map generic types.

Create a new instance that will map generic types.

Build key to map to. This must be or contain an open generic type.

Maps the build key.

The build key to map. Current build context. Used for contextual information if writing a more sophisticated mapping. The new build key.

A that will look for a build plan in the current context. If it exists, it invokes it, otherwise it creates one and stores it for later, and invokes it.

Called during the chain of responsibility for a build operation.

The context for the operation.

An implementation of that chooses constructors based on these criteria: first, pick a constructor marked with the attribute. If there isn't one, then choose the constructor with the longest parameter list. If that is ambiguous, then throw.

Thrown when the constructor to choose is ambiguous. Attribute used to mark the constructor to call.

Base class that provides an implementation of which lets you override how the parameter resolvers are created.

A that, when implemented, will determine which constructor to call from the build plan.

Choose the constructor to call for the given type.

Current build context The to add any generated resolver objects into. The chosen constructor.

Choose the constructor to call for the given type.

Current build context The to add any generated resolver objects into. The chosen constructor.

Create a instance for the given .

Parameter to create the resolver for. The resolver object.

Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.

Value Condition Less than zerox is less than y.Zerox equals y.Greater than zerox is greater than y. The second object to compare. The first object to compare.

Create a instance for the given .

Parameter to create the resolver for. The resolver object.

Objects of this type are the return value from . It encapsulates the desired with the string keys needed to look up the for each parameter.

Base class for return values from selector policies that return a memberinfo of some sort plus a list of parameter keys to look up the parameter resolvers.

Base class for return of selector policies that need to keep track of a set of parameter keys.

Add a new parameter key to this object. Keys are assumed to be in the order of the parameters to the constructor.

Key for the next parameter to look up.

The set of keys for the constructor parameters.

Construct a new , storing the given member info.

Member info to store.

The member info stored.

Create a new instance which contains the given constructor.

The constructor to wrap.

The constructor this object wraps.

This class records the information about which constructor argument is currently being resolved, and is responsible for generating the error string required when an error has occurred.

Initializes a new instance of the class.

The type that is being constructed. A string representing the constructor being called. Parameter being resolved.

Generate the string describing what parameter was being resolved.

The description string.

String describing the constructor being set up.

Parameter that's being resolved.

A that emits IL to call constructors as part of creating a build plan.

Called during the chain of responsibility for a build operation.

Existing object is an instance of . The context for the operation.

A helper method used by the generated IL to throw an exception if a dependency cannot be resolved.

The currently being used for the build of this object.

A helper method used by the generated IL to throw an exception if a dependency cannot be resolved because of an invalid constructor.

The currently being used for the build of this object. The signature of the invalid constructor.

A helper method used by the generated IL to throw an exception if no existing object is present, but the user is attempting to build an interface (usually due to the lack of a type mapping).

The currently being used for the build of this object.

A helper method used by the generated IL to store the current operation in the build context.

A helper method used by the generated IL to set up a PerResolveLifetimeManager lifetime manager if the current object is such.

Current build context.

A class that records that a constructor is about to be call, and is responsible for generating the error string required when an error has occurred.

Initializes a new instance of the class.

Generate the description string.

The string.

Constructor we're trying to call.

An implementation of that will check for full trust and if we're building a class or an interface. If in full trust, attach to the class or module of the interface respectively. If in partial trust, attach to the OB2 module instead.

This interface defines a policy that manages creation of the dynamic methods used by the ObjectBuilder code generation. This way, we can replace the details of how the dynamic method is created to handle differences in CLR (like Silverlight vs desktop) or security policies.

Create a builder method for the given type, using the given name.

Type that will be built by the generated method. Name to give to the method. A object with the proper signature to use as part of a build plan.

Create a builder method for the given type, using the given name.

Type that will be built by the generated method. Name to give to the method. A object with the proper signature to use as part of a build plan.

This object tracks the current state of the build plan generation, accumulates the IL, provides the preamble & postamble for the dynamic method, and tracks things like local variables in the generated IL so that they can be reused across IL generation strategies.

Create a that is initialized to handle creation of a dynamic method to build the given type.

Type that we're trying to create a build plan for. An object that actually creates our object.

Completes generation of the dynamic method and returns the generated dynamic method delegate.

The created

Emit the IL to put the build context on top of the IL stack.

Emit the IL to put the current build key on top of the IL stack.

Emit the IL to put the current "existing" object on the top of the IL stack.

Emit the IL to make the top of the IL stack our current "existing" object.

Emit the IL to load the given object onto the top of the IL stack.

Type to load on the stack.

Emit the IL needed to look up an and call it to get a value.

Type of the dependency to resolve. Key to look up the policy by.

Emit the IL needed to clear the .

Emit the IL needed to either cast the top of the stack to the target type or unbox it, if it's a value type.

Type to convert the top of the stack to.

A helper method used by the generated IL to clear the current operation in the build context.

Helper method used by generated IL to look up a dependency resolver based on the given key.

Current build context. Type of the dependency being resolved. Key the resolver was stored under. The found dependency resolver.

A reflection helper method to make it easier to grab a property getter for the given property.

Type that implements the property we want. Type of the property. Name of the property. The property getter's .

A reflection helper method that makes it easier to grab a for a method.

Type that implements the method we want. Name of the method. Types of arguments to the method. The method's .

The underlying that can be used to emit IL into the generated dynamic method.

The type we're currently creating the method to build.

A delegate type that defines the signature of the dynamic method created by the build plans.

used to build up the object.

An implementation of that runs the given delegate to execute the plan.

An implementation that constructs a build plan via dynamic IL emission.

A that can create and return an for the given build key.

Create a build plan using the given context and build key.

Current build context. Current build key. The build plan.

Construct a that uses the given strategy chain to construct the build plan.

The strategy chain.

Construct a build plan.

The current build context. The current build key. The created build plan.

A class that records that a constructor is about to be call, and is responsible for generating the error string required when an error has occurred.

Initializes a new instance of the class.

Generate the description string.

The string.

Method we're trying to call.

This class records the information about which constructor argument is currently being resolved, and is responsible for generating the error string required when an error has occurred.

Initializes a new instance of the class.

The type that is being constructed. A string representing the method being called. Parameter being resolved.

Generate the string describing what parameter was being resolved.

The description string.

String describing the method being set up.

Parameter that's being resolved.

A that generates IL to call chosen methods (as specified by the current ) as part of object build up.

Called during the chain of responsibility for a build operation. The PreBuildUp method is called when the chain is being executed in the forward direction.

Context of the build operation.

A helper method used by the generated IL to store the current operation in the build context.

A base class that holds the information shared by all operations performed by the container while setting properties.

Initializes a new instance of the class.

Generate the description of this operation.

The string.

Get a format string used to create the description. Called by the base method.

The format string.

The property value currently being resolved.

This class records the information about which property value is currently being resolved, and is responsible for generating the error string required when an error has occurred.

Initializes a new instance of the class.

Get a format string used to create the description. Called by the base method.

The format string.

A that generates IL to resolve properties on an object being built.

Called during the chain of responsibility for a build operation.

The context for the operation.

A helper method used by the generated IL to store the current operation in the build context.

This class records the information about which property value is currently being set, and is responsible for generating the error string required when an error has occurred.

Initializes a new instance of the class.

Type property is on. Name of property being set.

Get a format string used to create the description. Called by the base method.

The format string.

Creates an instance of this build plan's type, or fills in the existing type if passed in.

Context used to build up the object.

An that will examine the given types and return a sequence of objects that should be called as part of building the object.

Return the sequence of methods to call while building the target object.

Current build context. The to add any generated resolver objects into. Sequence of methods to call.

An implementation of that selects methods by looking for the given attribute on those methods.

Type of attribute used to mark methods to inject.

Base class that provides an implementation of which lets you override how the parameter resolvers are created.

Attribute that marks methods that should be called.

Return the sequence of methods to call while building the target object.

Current build context. The to add any generated resolver objects into. Sequence of methods to call.

Create a instance for the given .

Parameter to create the resolver for. The resolver object.

Create a instance for the given .

Parameter to create the resolver for. The resolver object.

Objects of this type are the return value from . It encapsulates the desired with the string keys needed to look up the for each parameter.

Create a new instance which contains the given method.

The method

The constructor this object wraps.

An that returns a sequence of properties that should be injected for the given type.

Returns sequence of properties on the given type that should be set as part of building that object.

Current build context. The to add any generated resolver objects into. Sequence of objects that contain the properties to set.

Base class that provides an implementation of which lets you override how the parameter resolvers are created.

Returns sequence of properties on the given type that should be set as part of building that object.

Current build context. The to add any generated resolver objects into. Sequence of objects that contain the properties to set.

Create a for the given property.

Property to create resolver for. The resolver object.

An implementation of that looks for properties marked with the attribute that are also settable and not indexers.

Create a for the given property.

Property to create resolver for. The resolver object.

Objects of this type are returned from . This class combines the about the property with the string key used to look up the resolver for this property's value.

Create an instance of with the given and key.

The property. Key to use to look up the resolver.

PropertyInfo for this property.

Key to look up this property's resolver.

Implementation of .

A builder policy that lets you keep track of the current resolvers and will remove them from the given policy set.

Add a new resolver to track by key.

Key that was used to add the resolver to the policy set.

Remove the currently tracked resolvers from the given policy list.

Policy list to remove the resolvers from.

Add a new resolver to track by key.

Key that was used to add the resolver to the policy set.

Remove the currently tracked resolvers from the given policy list.

Policy list to remove the resolvers from.

Get an instance that implements , either the current one in the policy set or creating a new one if it doesn't exist.

Policy list to look up from. Build key to track. The resolver tracker.

Add a key to be tracked to the current tracker.

Policy list containing the resolvers and trackers. Build key for the resolvers being tracked. Key for the resolver.

Remove the resolvers for the given build key.

Policy list containing the build key. Build key.

An implementation of that calls back into the build chain to build up the dependency, passing a type given at compile time as its build key.

Create a new instance storing the given type.

Type to resolve.

Get the value for a dependency.

Current build context. The value for the dependency.

This interface defines a standard method to convert any regardless of the stage enum into a regular, flat strategy chain.

Convert this into a flat .

The flattened .

Represents a chain of responsibility for builder strategies.

Reverse the order of the strategy chain.

The reversed strategy chain.

Execute this strategy chain against the given context, calling the Buildup methods on the strategies.

Context for the build process. The build up object

Execute this strategy chain against the given context, calling the TearDown methods on the strategies.

Context for the teardown process.

A builder policy used to create lifetime policy instances. Used by the LifetimeStrategy when instantiating open generic types.

Create a new instance of .

The new instance.

The type of Lifetime manager that will be created by this factory.

An implementation that uses a to figure out if an object has already been created and to update or remove that object from some backing store.

Called during the chain of responsibility for a build operation. The PreBuildUp method is called when the chain is being executed in the forward direction.

Context of the build operation.

Represents a chain of responsibility for builder strategies partitioned by stages.

The stage enumeration to partition the strategies.

Initialize a new instance of the class.

Initialize a new instance of the class with an inner strategy chain to use when building.

The inner strategy chain to use first when finding strategies in the build operation.

Adds a strategy to the chain at a particular stage.

The strategy to add to the chain. The stage to add the strategy.

Add a new strategy for the .

The of The stage to add the strategy.

Clear the current strategy chain list.

This will not clear the inner strategy chain if this instane was created with one.

Makes a strategy chain based on this instance.

A new .

Represents a chain of responsibility for builder strategies.

Initialzie a new instance of the class.

Initialzie a new instance of the class with a colleciton of strategies.

A collection of strategies to initialize the chain.

Adds a strategy to the chain.

The strategy to add to the chain.

Adds strategies to the chain.

The strategies to add to the chain.

Reverse the order of the strategy chain.

The reversed strategy chain.

Execute this strategy chain against the given context to build up.

Context for the build processes. The build up object

Execute this strategy chain against the given context, calling the TearDown methods on the strategies.

Context for the teardown process.

Returns an enumerator that iterates through the collection.

A that can be used to iterate through the collection. 1

Returns an enumerator that iterates through a collection.

An object that can be used to iterate through the collection. 2

Build key used to combine a type object with a string name. Used by ObjectBuilder to indicate exactly what is being built.

Create a new instance with the given type and name.

to build. Key to use to look up type mappings and singletons.

Create a new instance for the default buildup of the given type.

to build.

This helper method creates a new instance. It is initialized for the default key for the given type.

Type to build. A new instance.

This helper method creates a new instance for the given type and key.

Type to build Key to use to look up type mappings and singletons. A new instance initialized with the given type and name.

Compare two instances.

Two instances compare equal if they contain the same name and the same type. Also, comparing against a different type will also return false. Object to compare to. True if the two keys are equal, false if not.

Calculate a hash code for this instance.

A hash code.

Compare two instances for equality.

Two instances compare equal if they contain the same name and the same type. First of the two keys to compare. Second of the two keys to compare. True if the values of the keys are the same, else false.

Compare two instances for inequality.

Two instances compare equal if they contain the same name and the same type. If either field differs the keys are not equal. First of the two keys to compare. Second of the two keys to compare. false if the values of the keys are the same, else true.

Formats the build key as a string (primarily for debugging).

A readable string representation of the build key.

Return the stored in this build key.

The type to build.

Returns the name stored in this build key.

The name to use when building.

A generic version of so that you can new up a key using generic syntax.

Type for the key.

Construct a new that specifies the given type.

Construct a new that specifies the given type and name.

Name for the key.

A series of helper methods to deal with sequences - objects that implement .

A function that turns an arbitrary parameter list into an .

Type of arguments. The items to put into the collection. An array that contains the values of the .

Given two sequences, return a new sequence containing the corresponding values from each one.

Type of first sequence. Type of second sequence. First sequence of items. Second sequence of items. New sequence of pairs. This sequence ends when the shorter of sequence1 and sequence2 does.

The exception thrown by the Unity container when an attempt to resolve a dependency fails.

Constructor to create a from serialized state.

Serialization info Serialization context

Serialize this object into the given context.

Serialization info Streaming context

Create a new that records the exception for the given type and name.

Type requested from the container. Name requested from the container. The actual exception that caused the failure of the build. The build context representing the failed operation.

The type that was being requested from the container at the time of failure.

The name that was being requested from the container at the time of failure.

A that lets you register a delegate with the container to create an object, rather than calling the object's constructor.

Base class for all extension objects.

The container calls this method when the extension is added.

A instance that gives the extension access to the internals of the container.

Initial the container with this extension's functionality.

When overridden in a derived class, this method will modify the given by adding strategies, policies, etc. to install it's functions into the container.

Removes the extension's functions from the container.

This method is called when extensions are being removed from the container. It can be used to do things like disconnect event handlers or clean up member state. You do not need to remove strategies or policies here; the container will do that automatically. The default implementation of this method does nothing.

The container this extension has been added to.

The that this extension has been added to.

The object used to manipulate the inner state of the container.

Initialize this extension. This particular extension requires no initialization work.

Type that will be requested from the container. Delegate to invoke to create the instance. The container extension object this method was invoked on.

An implementation of that acts as a decorator over another . This checks to see if the current type being built is the right one before checking the inner .

Create an instance of

Type to check for. Inner override to check after type matches.

Return a that can be used to give a value for the given desired dependency.

Current build context. Type of dependency desired. a object if this override applies, null if not.

A convenience version of that lets you specify the type to construct via generics syntax.

Type to check for.

Create an instance of .

Inner override to check after type matches.

Extension class that adds a set of convenience overloads to the interface.

Type this registration is for. Container to configure. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

This method is used to tell the container that when asked for type , actually return an instance of type . This is very useful for getting instances of interfaces. This overload registers a default mapping and transient lifetime. that will be requested. that will actually be returned. Container to configure. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

that will be requested. that will actually be returned. Container to configure. The that controls the lifetime of the returned instance. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

This method is used to tell the container that when asked for type , actually return an instance of type . This is very useful for getting instances of interfaces. that will be requested. that will actually be returned. Container to configure. Name of this mapping. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

that will be requested. that will actually be returned. Container to configure. Name to use for registration, null if a default registration. The that controls the lifetime of the returned instance. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

The type to apply the to. Container to configure. The that controls the lifetime of the returned instance. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

The type to configure injection on. Container to configure. Name that will be used to request the type. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

The type to apply the to. Container to configure. Name that will be used to request the type. The that controls the lifetime of the returned instance. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

Container to configure. Type this registration is for. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

This method is used to tell the container that when asked for type , actually return an instance of type . This is very useful for getting instances of interfaces. This overload registers a default mapping. Container to configure. that will be requested. that will actually be returned. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

This method is used to tell the container that when asked for type , actually return an instance of type . This is very useful for getting instances of interfaces. Container to configure. that will be requested. that will actually be returned. Name to use for registration, null if a default registration. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

Container to configure. that will be requested. that will actually be returned. The that controls the lifetime of the returned instance. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

Container to configure. The to apply the to. The that controls the lifetime of the returned instance. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

Container to configure. The to configure in the container. Name to use for registration, null if a default registration. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

Container to configure. The to apply the to. Name to use for registration, null if a default registration. The that controls the lifetime of the returned instance. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

Instance registration is much like setting a type as a singleton, except that instead of the container creating the instance the first time it is requested, the user creates the instance ahead of type and adds that instance to the container. This overload does a default registration and has the container take over the lifetime of the instance. Type of instance to register (may be an implemented interface instead of the full type). Container to configure. Object to returned. The object that this method was called on (this in C#, Me in Visual Basic).

Instance registration is much like setting a type as a singleton, except that instead of the container creating the instance the first time it is requested, the user creates the instance ahead of type and adds that instance to the container. This overload does a default registration (name = null). Type of instance to register (may be an implemented interface instead of the full type). Container to configure. Object to returned. object that controls how this instance will be managed by the container. The object that this method was called on (this in C#, Me in Visual Basic).

Instance registration is much like setting a type as a singleton, except that instead of the container creating the instance the first time it is requested, the user creates the instance ahead of type and adds that instance to the container. This overload automatically has the container take ownership of the . Type of instance to register (may be an implemented interface instead of the full type). Object to returned. Container to configure. Name for registration. The object that this method was called on (this in C#, Me in Visual Basic).

Instance registration is much like setting a type as a singleton, except that instead of the container creating the instance the first time it is requested, the user creates the instance ahead of type and adds that instance to the container. Type of instance to register (may be an implemented interface instead of the full type). Object to returned. Container to configure. Name for registration. object that controls how this instance will be managed by the container. The object that this method was called on (this in C#, Me in Visual Basic).

Instance registration is much like setting a type as a singleton, except that instead of the container creating the instance the first time it is requested, the user creates the instance ahead of type and adds that instance to the container. This overload does a default registration and has the container take over the lifetime of the instance. Container to configure. Type of instance to register (may be an implemented interface instead of the full type). Object to returned. The object that this method was called on (this in C#, Me in Visual Basic).

Instance registration is much like setting a type as a singleton, except that instead of the container creating the instance the first time it is requested, the user creates the instance ahead of type and adds that instance to the container. This overload does a default registration (name = null). Container to configure. Type of instance to register (may be an implemented interface instead of the full type). Object to returned. object that controls how this instance will be managed by the container. The object that this method was called on (this in C#, Me in Visual Basic).

Instance registration is much like setting a type as a singleton, except that instead of the container creating the instance the first time it is requested, the user creates the instance ahead of type and adds that instance to the container. This overload automatically has the container take ownership of the . Container to configure. Type of instance to register (may be an implemented interface instead of the full type). Object to returned. Name for registration. The object that this method was called on (this in C#, Me in Visual Basic).

Resolve an instance of the default requested type from the container.

of object to get from the container. Container to resolve from. Any overrides for the resolve call. The retrieved object.

Resolve an instance of the requested type with the given name from the container.

of object to get from the container. Container to resolve from. Name of the object to retrieve. Any overrides for the resolve call. The retrieved object.

Resolve an instance of the default requested type from the container.

Container to resolve from. of object to get from the container. Any overrides for the resolve call. The retrieved object.

Return instances of all registered types requested.

This method is useful if you've registered multiple types with the same but different names. Be aware that this method does NOT return an instance for the default (unnamed) registration. The type requested. Container to resolve from. Any overrides for the resolve calls. Set of objects of type .

Run an existing object through the container and perform injection on it.

This method is useful when you don't control the construction of an instance (ASP.NET pages or objects created via XAML, for instance) but you still want properties and other injection performed. This overload uses the default registrations. of object to perform injection on. Container to resolve through. Instance to build up. Any overrides for the buildup. The resulting object. By default, this will be , but container extensions may add things like automatic proxy creation which would cause this to return a different object (but still type compatible with ).

Run an existing object through the container and perform injection on it.

This method is useful when you don't control the construction of an instance (ASP.NET pages or objects created via XAML, for instance) but you still want properties and other injection performed. of object to perform injection on. Conatiner to resolve through. Instance to build up. name to use when looking up the typemappings and other configurations. Any overrides for the Buildup. The resulting object. By default, this will be , but container extensions may add things like automatic proxy creation which would cause this to return a different object (but still type compatible with ).

Run an existing object through the container and perform injection on it.

This method is useful when you don't control the construction of an instance (ASP.NET pages or objects created via XAML, for instance) but you still want properties and other injection performed. This overload uses the default registrations. Container to resolve through. of object to perform injection on. Instance to build up. Any overrides for the Buildup. The resulting object. By default, this will be , but container extensions may add things like automatic proxy creation which would cause this to return a different object (but still type compatible with ).

Creates a new extension object and adds it to the container.

Type of to add. The extension type will be resolved from within the supplied . Container to add the extension to. The object that this method was called on (this in C#, Me in Visual Basic).

Resolve access to a configuration interface exposed by an extension.

Extensions can expose configuration interfaces as well as adding strategies and policies to the container. This method walks the list of added extensions and returns the first one that implements the requested type. The configuration interface required. Container to configure. The requested extension's configuration interface, or null if not found.

Check if a particular type has been registered with the container with the default name.

Container to inspect. Type to check registration for. True if this type has been registered, false if not.

Check if a particular type/name pair has been registered with the container.

Container to inspect. Type to check registration for. Name to check registration for. True if this type/name pair has been registered, false if not.

Check if a particular type has been registered with the container with the default name.

Type to check registration for. Container to inspect. True if this type has been registered, false if not.

Check if a particular type/name pair has been registered with the container.

Type to check registration for. Container to inspect. Name to check registration for. True if this type/name pair has been registered, false if not.

This extension installs the default strategies and policies into the container to implement the standard behavior of the Unity container.

Add the correct to the policy set. This version adds the appropriate policy for running on the desktop CLR.

Add the default ObjectBuilder strategies & policies to the container.

The class provides the means for extension objects to manipulate the internal state of the .

Store a type/name pair for later resolution.

When users register type mappings (or other things) with a named key, this method allows you to register that name with the container so that when the method is called, that name is included in the list that is returned. to register. Name assocated with that type.

The container that this context is associated with.

The object.

The strategies this container uses.

The that the container uses to build objects.

The strategies this container uses to construct build plans.

The that this container uses when creating build plans.

The policies this container uses.

The the that container uses to build objects.

The that this container uses.

The is used to manage objects that the container is managing.

This event is raised when the method, or one of its overloads, is called.

This event is raised when the method is called, providing the newly created child container to extensions to act on as they see fit.

An EventArgs class that holds a string Name.

Create a new with a null name.

Create a new with the given name.

Name to store.

The name.

Name used for this event arg object.

Event argument class for the event.

Create a new instance of .

Type to map from. Type to map to. Name for the registration. to manage instances.

Type to map from.

Type to map to.

to manage instances.

Event argument class for the event.

Create a default instance.

Create a instance initialized with the given arguments.

Type of instance being registered. The instance object itself. Name to register under, null if default registration. object that handles how the instance will be owned.

Type of instance being registered.

Instance object being registered.

Instance object being registered

that controls ownership of this instance.

A that lets you specify that an instance of a generic type parameter should be resolved.

Create a new instance that specifies that the given named generic parameter should be resolved.

The generic parameter name to resolve.

Create a new instance that specifies that the given named generic parameter should be resolved.

The generic parameter name to resolve. name to use when looking up in the container.

Return a instance that will return this types value for the parameter.

The actual type to resolve. The resolution key. The .

A that lets you specify that an array containing the registered instances of a generic type parameter should be resolved.

Create a new instance that specifies that the given named generic parameter should be resolved.

The generic parameter name to resolve. The values for the elements, that will be converted to objects.

Test to see if this parameter value has a matching type for the given type.

Type to check. True if this parameter value is compatible with type , false if not. A type is considered compatible if it is an array type of rank one and its element type is a generic type parameter with a name matching this generic parameter name configured for the receiver.

Return a instance that will return this types value for the parameter.

Type that contains the member that needs this parameter. Used to resolve open generic parameters. The .

Name for the type represented by this . This may be an actual type name or a generic argument name.

A Unity container extension that allows you to configure which constructors, properties, and methods get injected via an API rather than through attributes.

Initial the container with this extension's functionality.

When overridden in a derived class, this method will modify the given by adding strategies, policies, etc. to install it's functions into the container.

API to configure the injection settings for a particular type.

Type the injection is being configured for. Objects containing the details on which members to inject and how. This extension object.

API to configure the injection settings for a particular type/name pair.

Type the injection is being configured for. Name of registration Objects containing the details on which members to inject and how. This extension object.

API to configure the injection settings for a particular type.

Type to configure. Objects containing the details on which members to inject and how. This extension object.

API to configure the injection settings for a particular type/name pair.

Type to configure. Name of registration. Objects containing the details on which members to inject and how. This extension object.

API to configure the injection settings for a particular type/name pair.

Type of interface/base class being registered (may be null). Type of actual implementation class being registered. Name of registration. Objects containing the details on which members to inject and how. This extension object.

A class that holds the collection of information for a constructor, so that the container can be configured to call this constructor.

Create a new instance of that looks for a constructor with the given set of parameters.

The values for the parameters, that will be converted to objects.

Add policies to the to configure the container to call this constructor with the appropriate parameter values.

Interface registered, ignored in this implementation. Type to register. Name used to resolve the type object. Policy list to add policies to.

An that configures the container to call a method as part of buildup.

Create a new instance which will configure the container to call the given methods with the given parameters.

Name of the method to call. Parameter values for the method.

Add policies to the to configure the container to call this constructor with the appropriate parameter values.

Type of interface registered, ignored in this implementation. Type to register. Name used to resolve the type object. Policy list to add policies to.

A small function to handle name matching. You can override this to do things like case insensitive comparisons.

MethodInfo for the method you're checking. Name of the method you're looking for. True if a match, false if not.

A class that holds on to the given value and provides the required when the container is configured.

Create an instance of that stores the given value, using the runtime type of that value as the type of the parameter.

Value to be injected for this parameter.

Create an instance of that stores the given value, associated with the given type.

Type of the parameter. Value of the parameter

Return a instance that will return this types value for the parameter.

Type that contains the member that needs this parameter. Used to resolve open generic parameters. The .

A generic version of that makes it a little easier to specify the type of the parameter.

Type of parameter.

Create a new .

Value for the parameter.

This class stores information about which properties to inject, and will configure the container accordingly.

Configure the container to inject the given property name, resolving the value via the container.

Name of the property to inject.

Configure the container to inject the given property name, using the value supplied. This value is converted to an object using the rules defined by the method.

Name of property to inject. Value for property.

Add policies to the to configure the container to call this constructor with the appropriate parameter values.

Interface being registered, ignored in this implemenation. Type to register. Name used to resolve the type object. Policy list to add policies to.

A class that stores a type, and generates a resolver object that resolves all the named instances or the type registered in a container.

Construct a new that resolves to the given element type and collection of element values.

The type of elements to resolve. The values for the elements, that will be converted to objects.

Construct a new that resolves to the given array and element types and collection of element values.

The type for the array of elements to resolve. The type of elements to resolve. The values for the elements, that will be converted to objects.

Return a instance that will return this types value for the parameter.

Type that contains the member that needs this parameter. Used to resolve open generic parameters. The .

A generic version of for convenience when creating them by hand.

Type of the elements for the array of the parameter.

Construct a new that resolves to the given element generic type with the given element values.

The values for the elements, that will be converted to objects.

Interface defining the behavior of the Unity dependency injection container.

that will be requested. that will actually be returned. Name to use for registration, null if a default registration. The that controls the lifetime of the returned instance. Injection configuration objects. The object that this method was called on (this in C#, Me in Visual Basic).

Resolve an instance of the requested type with the given name from the container.

of object to get from the container. Name of the object to retrieve. Any overrides for the resolve call. The retrieved object.

Return instances of all registered types requested.

This method is useful if you've registered multiple types with the same but different names. Be aware that this method does NOT return an instance for the default (unnamed) registration. The type requested. Any overrides for the resolve calls. Set of objects of type .

Run an existing object through the container and perform injection on it.

This method is useful when you don't control the construction of an instance (ASP.NET pages or objects created via XAML, for instance) but you still want properties and other injection performed. of object to perform injection on. Instance to build up. name to use when looking up the typemappings and other configurations. Any overrides for the resolve calls. The resulting object. By default, this will be , but container extensions may add things like automatic proxy creation which would cause this to return a different object (but still type compatible with ).

Run an existing object through the container, and clean it up.

The object to tear down.

Add an extension object to the container.

to add. The object that this method was called on (this in C#, Me in Visual Basic).

Resolve access to a configuration interface exposed by an extension.

Extensions can expose configuration interfaces as well as adding strategies and policies to the container. This method walks the list of added extensions and returns the first one that implements the requested type. of configuration interface required. The requested extension's configuration interface, or null if not found.

Remove all installed extensions from this container.

This method removes all extensions from the container, including the default ones that implement the out-of-the-box behavior. After this method, if you want to use the container again you will need to either readd the default extensions or replace them with your own. The registered instances and singletons that have already been set up in this container do not get removed. The object that this method was called on (this in C#, Me in Visual Basic).

Create a child container.

A child container shares the parent's configuration, but can be configured with different settings or lifetime. The new child container.

The parent of this container.

The parent container, or null if this container doesn't have one.

Get a sequence of that describe the current state of the container.

A that holds a weak reference to it's managed instance.

Retrieve a value from the backing store associated with this Lifetime policy.

the object desired, or null if no such object is currently stored.

Stores the given value into backing store for retrieval later.

The object being stored.

Remove the given object from backing store.

An implementation of that creates instances of the type of the given Lifetime Manager by resolving them through the container.

Create a new that will return instances of the given type, creating them by resolving through the container.

Container to resolve with. Type of LifetimeManager to create.

Create a new instance of .

The new instance.

The type of Lifetime manager that will be created by this factory.

A that holds the instances given to it, keeping one instance per thread.

This LifetimeManager does not dispose the instances it holds.

Initializes a new instance of the class.

Retrieve a value from the backing store associated with this Lifetime policy for the current thread.

the object desired, or if no such object is currently stored for the current thread.

Stores the given value into backing store for retrieval later when requested in the current thread.

The object being stored.

Remove the given object from backing store.

Not implemented for this lifetime manager.

An implementation that does nothing, thus ensuring that instances are created new every time.

Retrieve a value from the backing store associated with this Lifetime policy.

the object desired, or null if no such object is currently stored.

Stores the given value into backing store for retrieval later.

The object being stored.

Remove the given object from backing store.

This strategy implements the logic that will call container.ResolveAll when an array parameter is detected.

Do the PreBuildUp stage of construction. This is where the actual work is performed.

Current build context.

An implementation of that is aware of the build keys used by the Unity container.

Create a instance for the given .

This implementation looks for the Unity on the parameter and uses it to create an instance of for this parameter. Parameter to create the resolver for. The resolver object.

An implementation of that is aware of the build keys used by the Unity container.

Create a instance for the given .

Parameter to create the resolver for. The resolver object.

An implementation of that is aware of the build keys used by the unity container.

Create a for the given property.

Property to create resolver for. The resolver object.

A implementation that returns the value set in the constructor.

Create a new instance of which will return the given value when resolved.

The value to return.

Get the value for a dependency.

Current build context. The value for the dependency.

An implementation of that stores a type and name, and at resolution time puts them together into a .

Create an instance of with the given type and name.

The type. The name (may be null).

Resolve the value for a dependency.

Current build context. The value for the dependency.

The type that this resolver resolves.

The name that this resolver resolves.

An implementation of that resolves to to an array populated with the values that result from resolving other instances of .

Create an instance of with the given type and a collection of instances to use when populating the result.

The type. The resolver policies to use when populating an array.

Resolve the value for a dependency.

Current build context. An array pupulated with the results of resolving the resolver policies.

An implementation of that selects the given constructor and creates the appropriate resolvers to call it with the specified parameters.

Create an instance of that will return the given constructor, being passed the given injection values as parameters.

The constructor to call. Set of objects that describes how to obtain the values for the constructor parameters.

Choose the constructor to call for the given type.

Current build context The to add any generated resolver objects into. The chosen constructor.

Helper class for implementing selector policies that need to set up dependency resolver policies.

Add dependency resolvers to the parameter set.

Type that's currently being built (used to resolve open generics). PolicyList to add the resolvers to. Objects supplying the dependency resolvers. Result object to store the keys in.

A implementation that calls the specific methods with the given parameters.

Add the given method and parameter collection to the list of methods that will be returned when the selector's method is called.

Method to call. sequence of objects that describe how to create the method parameter values.

Return the sequence of methods to call while building the target object.

Current build context. The to add any generated resolver objects into. Sequence of methods to call.

An implemnetation of which returns the set of specific properties that the selector was configured with.

Add a property that will be par of the set returned when the is called.

The property to set. object describing how to create the value to inject.

Returns sequence of properties on the given type that should be set as part of building that object.

Current build context. The to add any generated resolver objects into. Sequence of objects that contain the properties to set.

A class that stores a name and type, and generates a resolver object that resolves the parameter via the container.

Construct a new that resolves to the given type.

Type of this parameter.

Construct a new that resolves the given type and name.

Type of this parameter. Name to use when resolving parameter.

Return a instance that will return this types value for the parameter.

Type that contains the member that needs this parameter. Used to resolve open generic parameters. The .

A generic version of for convenience when creating them by hand.

Type of the parameter

Create a new for the given generic type and the default name.

Create a new for the given generic type and name.

Name to use to resolve this parameter.

An implementation of that wraps a Unity container.

Initializes a new instance of the class for a container.

The to wrap with the interface implementation.

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

When implemented by inheriting classes, this method will do the actual work of resolving the requested service instance.

Type of instance requested.Name of registered service you want. May be null. The requested service instance.

When implemented by inheriting classes, this method will do the actual work of resolving all the requested service instances.

Type of service requested. Sequence of service instance objects.

A static helper class that includes various parameter checking routines.

Throws if the given argument is null.

if tested value if null. Argument value to test. Name of the argument being tested.

Throws an exception if the tested string argument is null or the empty string.

Thrown if string value is null. Thrown if the string is empty Argument value to check. Name of argument being checked.

Verifies that an argument type is assignable from the provided type (meaning interfaces are implemented, or classes exist in the base class hierarchy).

The argument type that will be assigned to. The type of the value being assigned. Argument name.

Verifies that an argument instance is assignable from the provided type (meaning interfaces are implemented, or classes exist in the base class hierarchy, or instance can be assigned through a runtime wrapper, as is the case for COM Objects).

The argument type that will be assigned to. The instance that will be assigned. Argument name.

The build stages we use in the Unity container strategy pipeline.

First stage. By default, nothing happens here.

Second stage. Type mapping occurs here.

Third stage. lifetime managers are checked here, and if they're available the rest of the pipeline is skipped.

Fourth stage. Reflection over constructors, properties, etc. is performed here.

Fifth stage. Instance creation happens here.

Sixth stage. Property sets and method injection happens here.

Seventh and final stage. By default, nothing happens here.

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to The type {0} has multiple constructors of length {1}. Unable to disambiguate..

Looks up a localized string similar to The provided string argument must not be empty..

Looks up a localized string similar to The current build operation (build key {2}) failed: {3} (Strategy type {0}, index {1}).

Looks up a localized string similar to The current type, {0}, is an interface and cannot be constructed. Are you missing a type mapping?.

Looks up a localized string similar to Cannot extract type from build key {0}..

Looks up a localized string similar to The method {0}.{1}({2}) is an open generic method. Open generic methods cannot be injected..

Looks up a localized string similar to The property {0} on type {1} is an indexer. Indexed properties cannot be injected..

Looks up a localized string similar to The method {1} on type {0} has an out parameter. Injection cannot be performed..

Looks up a localized string similar to The method {0}.{1}({2}) has at least one out parameter. Methods with out parameters cannot be injected..

Looks up a localized string similar to The method {0}.{1}({2}) has at least one ref parameter.Methods with ref parameters cannot be injected..

Looks up a localized string similar to The method {1} on type {0} is marked for injection, but it is an open generic method. Injection cannot be performed..

Looks up a localized string similar to The method {0}.{1}({2}) is static. Static methods cannot be injected..

Looks up a localized string similar to The type {0} is an open generic type. An open generic type cannot be resolved..

Looks up a localized string similar to Resolving parameter "{0}" of constructor {1}.

Looks up a localized string similar to The parameter {0} could not be resolved when attempting to call constructor {1}..

Looks up a localized string similar to Parameter type inference does not work for null values. Indicate the parameter type explicitly using a properly configured instance of the InjectionParameter or InjectionParameter<T> classes..

Looks up a localized string similar to Calling constructor {0}.

Looks up a localized string similar to Calling method {0}.{1}.

Looks up a localized string similar to An item with the given key is already present in the dictionary..

Looks up a localized string similar to The lifetime manager is already registered. Lifetime managers cannot be reused, please create a new one..

Looks up a localized string similar to The override marker build plan policy has been invoked. This should never happen, looks like a bug in the container..

Looks up a localized string similar to Resolving parameter "{0}" of method {1}.{2}.

Looks up a localized string similar to The value for parameter "{1}" of method {0} could not be resolved. .

Looks up a localized string similar to Could not resolve dependency for build key {0}..

Looks up a localized string similar to The type {0} has multiple constructors marked with the InjectionConstructor attribute. Unable to disambiguate..

Looks up a localized string similar to The supplied type {0} must be an open generic type..

Looks up a localized string similar to The supplied type {0} does not have the same number of generic arguments as the target type {1}..

Looks up a localized string similar to The type {0} does not have an accessible constructor..

Looks up a localized string similar to The type {0} does not have a generic argument named "{1}".

Looks up a localized string similar to while resolving.

Looks up a localized string similar to The type {0} does not have a constructor that takes the parameters ({1})..

Looks up a localized string similar to The type {0} does not have a public method named {1} that takes the parameters ({2})..

Looks up a localized string similar to The type {0} does not contain an instance property named {1}..

Looks up a localized string similar to The type {0} is not a generic type, and you are attempting to inject a generic parameter named "{1}"..

Looks up a localized string similar to The type {0} is not an array type with rank 1, and you are attempting to use a [DependencyArray] attribute on a parameter or property with this type..

Looks up a localized string similar to Optional dependencies must be reference types. The type {0} is a value type..

Looks up a localized string similar to The property {0} on type {1} is not settable..

Looks up a localized string similar to The property {0} on type {1} is of type {2}, and cannot be injected with a value of type {3}..

Looks up a localized string similar to The value for the property "{0}" could not be resolved..

Looks up a localized string similar to The provided string argument must not be empty..

Looks up a localized string similar to Resolution of the dependency failed, type = "{0}", name = "{1}". Exception occurred while: {2}. Exception is: {3} - {4} ----------------------------------------------- At the time of the exception, the container was: .

Looks up a localized string similar to Resolving {0},{1}.

Looks up a localized string similar to Resolving {0},{1} (mapped from {2}, {3}).

Looks up a localized string similar to Resolving value for property {0}.{1}.

Looks up a localized string similar to The constructor {1} selected for type {0} has ref or out parameters. Such parameters are not supported for constructor injection..

Looks up a localized string similar to Setting value for property {0}.{1}.

Looks up a localized string similar to The type {0} cannot be constructed. You must configure the container to supply this value..

Looks up a localized string similar to The type {1} cannot be assigned to variables of type {0}..

Looks up a localized string similar to <unknown>.

A simple, extensible dependency injection container.

Create a default .

Create a with the given parent container.

The parent . The current object will apply its own settings first, and then check the parent for additional ones.

RegisterType a type mapping with the container, where the created instances will use the given .

RegisterType an instance with the container.

Instance registration is much like setting a type as a singleton, except that instead of the container creating the instance the first time it is requested, the user creates the instance ahead of type and adds that instance to the container. Type of instance to register (may be an implemented interface instead of the full type). Object to returned. Name for registration. If true, the container will take over the lifetime of the instance, calling Dispose on it (if it's ) when the container is Disposed. If false, container will not maintain a strong reference to . User is reponsible for disposing instance, and for keeping the instance from being garbage collected. The object that this method was called on (this in C#, Me in Visual Basic).

Get an instance of the requested type with the given name from the container.

of object to get from the container. Name of the object to retrieve. Any overrides for the resolve call. The retrieved object.

Return instances of all registered types requested.

This method is useful if you've registered multiple types with the same but different names. Be aware that this method does NOT return an instance for the default (unnamed) registration. The type requested. Any overrides for the resolve calls. Set of objects of type .

Run an existing object through the container and perform injection on it.

This method is useful when you don't control the construction of an instance (ASP.NET pages or objects created via XAML, for instance) but you still want properties and other injection performed. of object to perform injection on. Instance to build up. name to use when looking up the typemappings and other configurations. Any overrides for the buildup. The resulting object. By default, this will be , but container extensions may add things like automatic proxy creation which would cause this to return a different object (but still type compatible with ).

Run an existing object through the container, and clean it up.

The object to tear down.

Add an extension object to the container.

to add. The object that this method was called on (this in C#, Me in Visual Basic).

Get access to a configuration interface exposed by an extension.

Extensions can expose configuration interfaces as well as adding strategies and policies to the container. This method walks the list of added extensions and returns the first one that implements the requested type. of configuration interface required. The requested extension's configuration interface, or null if not found.

Remove all installed extensions from this container.

Create a child container.

A child container shares the parent's configuration, but can be configured with different settings or lifetime. The new child container.

Dispose this container instance.

Disposing the container also disposes any child containers, and disposes any instances whose lifetimes are managed by the container.

Dispose this container instance.

This class doesn't have a finalizer, so will always be true. True if being called from the IDisposable.Dispose method, false if being called from a finalizer.

Remove policies associated with building this type. This removes the compiled build plan so that it can be rebuilt with the new settings the next time this type is resolved.

Type of object to clear the plan for. Name the object is being registered with.

The parent of this container.

The parent container, or null if this container doesn't have one.

Get a sequence of that describe the current state of the container.

Implementation of the ExtensionContext that is actually used by the UnityContainer implementation.

This is a nested class so that it can access state in the container that would otherwise be inaccessible.

This event is raised when the method, or one of its overloads, is called.

This extension supplies the default behavior of the UnityContainer API by handling the context events and setting policies.

Install the default container behavior into the container.

Remove the default behavior from the container.

Helper class to wrap common reflection stuff dealing with methods.

Create a new instance that lets us do more reflection stuff on that method.

The method to reflect on.

Given our set of generic type arguments,

The generic type arguments. An array with closed parameter types.

Returns true if any of the parameters of this method are open generics.

Return the of each parameter for this method.

Sequence of objects, one for each parameter in order.

A helper class that encapsulates two different data items together into a a single item.

Create a new containing the two values give.

First value Second value

The first value of the pair.

The second value of the pair.

Container for a Pair helper method.

A helper factory method that lets users take advantage of type inference.

Type of first value. Type of second value. First value. Second value. A new instance.

A utility class that handles the logic of matching parameter lists, so we can find the right constructor and method overloads.

Create a new that will attempt to match the given parameter types.

Target parameters to match against.

Tests to see if the given set of types matches the ones we're looking for.

parameter list to look for. true if they match, false if they don't.

Tests to see if the given set of types matches the ones we're looking for.

Candidate method signature to look for. True if they match, false if they don't.

Another reflection helper class that has extra methods for dealing with ParameterInfos.

A small helper class to encapsulate details of the reflection API, particularly around generics.

Create a new instance that lets you look at information about the given type.

Type to do reflection on.

Test the given object, looking at the parameters. Determine if any of the parameters are open generic types that need type attributes filled in.

The method to check. True if any of the parameters are open generics. False if not.

If this type is an open generic, use the given array to determine what the required closed type is and return that.

If the parameter is not an open type, just return this parameter's type. Type arguments to substitute in for the open type parameters. Corresponding closed type of this parameter.

Given a generic argument name, return the corresponding type for this closed type. For example, if the current type is SomeType<User>, and the corresponding definition was SomeType<TSomething>, calling this method and passing "TSomething" will return typeof(User).

Name of the generic parameter. Type of the corresponding generic parameter, or null if there is no matching name.

The object we're reflecting over.

Is this type generic?

Is this type an open generic (no type parameter specified)

Is this type an array type?

Is this type an array of generic elements?

The type of the elements in this type (if it's an array).

Create a new instance of that lets you query information about the given ParameterInfo object.

Parameter to query.

A set of helper methods to pick through lambdas and pull out from them.

Pull out a object from an expression of the form () => SomeClass.SomeMethod()

Expression describing the method to call. Corresponding .

Pull out a object from an expression of the form x => x.SomeMethod()

The type where the method is defined. Expression describing the method to call. Corresponding .

Pull out a object for the get method from an expression of the form x => x.SomeProperty

The type where the method is defined. The type for the property. Expression describing the property for which the get method is to be extracted. Corresponding .

Pull out a object for the set method from an expression of the form x => x.SomeProperty

The type where the method is defined. The type for the property. Expression describing the property for which the set method is to be extracted. Corresponding .

Pull out a object from an expression of the form () => new SomeType()

The type where the constructor is defined. Expression invoking the desired constructor. Corresponding .