Autofac
Provides support for accessing/invoking the set of build callbacks, invoked on scope/container build.
Executes the newly-registered build callbacks for a given scope/container..
The new scope/container.
Represent a collection of callbacks that can be run after a container or scope is 'built'.
Add a callback to the set that will get executed.
The callback to run.
Execute the callback for each build callback registered in this service.
The scope that has been built.
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 This set of build callbacks has already run..
Reflection activator data for concrete types.
Initializes a new instance of the class.
Type that will be activated.
Gets the instance activator based on the provided data.
Parameterises the construction of a container by a .
No options - the default behavior for container building.
Prevents inclusion of standard modules like support for
relationship types including etc.
Does not call on components implementing
this interface (useful for module testing.)
Reference object allowing location and update of a registration callback.
Initializes a new instance of the class.
An that executes a registration action
against an .
Thrown if is .
Gets or sets the callback to execute during registration.
An that executes a registration action
against an .
Thrown if is .
Gets the callback identifier.
A that uniquely identifies the callback action
in a set of callbacks.
Registration style for dynamic registrations.
Activator data that can provide an IInstanceActivator instance.
Gets the instance activator based on the provided data.
Hides standard Object members to make fluent interfaces
easier to read.
Based on blog post by @kzu here:
http://www.clariusconsulting.net/blogs/kzu/archive/2008/03/10/58301.aspx.
Standard System.Object member.
Standard result.
Standard System.Object member.
Standard result.
Standard System.Object member.
Standard result.
Standard System.Object member.
The other.
Standard result.
Data structure used to construct registrations.
The most specific type to which instances of the registration
can be cast.
Activator builder type.
Registration style type.
Gets the registration data.
Gets the activator data.
Gets the registration style.
Gets the resolve pipeline for this registration.
Configure the component so that instances are never disposed by the container.
A registration builder allowing further configuration of the component.
Configure the component so that instances that support IDisposable are
disposed by the container (default).
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
gets a new, unique instance (default).
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
gets the same, shared instance.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a single ILifetimeScope gets the same, shared instance. Dependent components in
different lifetime scopes will get different instances.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve() within
a ILifetimeScope tagged with any of the provided tags value gets the same, shared instance.
Dependent components in lifetime scopes that are children of the tagged scope will
share the parent's instance. If no appropriately tagged scope can be found in the
hierarchy an is thrown.
Tag applied to matching lifetime scopes.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
Service type.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
Service type.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
The service type provided by the component.
Key to associate with the component.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
The service type provided by the component.
Keys to associate with the component.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
Key to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide. The generic parameter(s) to As()
will be exposed as TypedService instances.
Service type.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide. The generic parameter(s) to As()
will be exposed as TypedService instances.
Service type.
Service type.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide. The generic parameter(s) to As()
will be exposed as TypedService instances.
Service type.
Service type.
Service type.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide.
Service types to expose.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide.
Services to expose.
A registration builder allowing further configuration of the component.
Provide a textual name that can be used to retrieve the component.
Named service to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Provide a textual name that can be used to retrieve the component.
Named service to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Provide a key that can be used to retrieve the component.
Key to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Provide a key that can be used to retrieve the component.
Key to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Add a handler for the Preparing event. This event allows manipulating of the parameters
that will be provided to the component.
The event handler.
A registration builder allowing further configuration of the component.
Add an async handler for the Preparing event. This event allows manipulating of the parameters
that will be provided to the component.
An event handler; the resolve process will not continue until the returned task completes.
A registration builder allowing further configuration of the component.
Add a handler for the Activating event.
The event handler.
A registration builder allowing further configuration of the component.
Add an async handler for the Activating event.
An event handler; the resolve process will not continue until the returned task completes.
A registration builder allowing further configuration of the component.
Add a handler for the Activated event.
The event handler.
A registration builder allowing further configuration of the component.
Add a handler for the Activated event.
An event handler; the resolve process will not continue until the returned task completes.
A registration builder allowing further configuration of the component.
Configure the component so that any properties whose types are registered in the
container and follow specific criteria will be wired to instances of the appropriate service.
Selector to determine which properties should be injected.
Determine if circular dependencies should be allowed or not.
A registration builder allowing further configuration of the component.
Associates data with the component.
Key by which the data can be located.
The data value.
A registration builder allowing further configuration of the component.
Associates data with the component.
The extended properties to associate with the component.
A registration builder allowing further configuration of the component.
Associates data with the component.
A type with properties whose names correspond to the
property names to configure.
The action used to configure the metadata.
A registration builder allowing further configuration of the component.
Provides access to the registration's pipeline builder, allowing custom middleware to be added.
An action that can configure the registration's pipeline.
A registration builder allowing further configuration of the component.
Used with the WithMetadata configuration method to
associate key-value pairs with an .
Interface with properties whose names correspond to
the property keys.
This feature was suggested by OJ Reeves (@TheColonial).
Gets the set of properties that have been provided.
Set one of the property values.
The type of the property.
An expression that accesses the property to set.
The property value to set.
Internal metadata keys.
Key containing the registration order.
Key containing a value indicating whether the registration has been auto activated.
Key containing a value indicating whether the registration should be started on activation.
Key containing the container build options.
Event handler for .
Event handler for .
Builder for reflection-based activators.
Initializes a new instance of the class.
Type that will be activated.
Gets or sets the implementation type.
Gets or sets the constructor finder for the registration.
Gets or sets the constructor selector for the registration.
Gets the explicitly bound constructor parameters.
Gets the explicitly bound properties.
Static factory methods to simplify the creation and handling of IRegistrationBuilder{L,A,R}.
To create an for a specific type, use:
var cr = RegistrationBuilder.ForType(t).CreateRegistration();
The full builder syntax is supported.
var cr = RegistrationBuilder.ForType(t).Named("foo").ExternallyOwned().CreateRegistration();
Creates a registration builder for the provided delegate.
Instance type returned by delegate.
Delegate to register.
A registration builder.
Creates a registration builder for the provided delegate.
Delegate to register.
Most specific type return value of delegate can be cast to.
A registration builder.
Creates a registration builder for the provided type.
Implementation type to register.
A registration builder.
Creates a registration builder for the provided type.
Implementation type to register.
A registration builder.
Create an from a .
There is no need to call this method when registering components through a .
When called on the result of one of the methods,
the returned registration will be different from the one the builder itself registers
in the container.
var registration = RegistrationBuilder.ForType<Foo>().CreateRegistration();
The registration builder.
An IComponentRegistration.
Thrown if is .
Create an IComponentRegistration from data.
Id of the registration.
Registration data.
Activator.
The component registration's resolve pipeline builder.
Services provided by the registration.
An IComponentRegistration.
Create an IComponentRegistration from data.
Id of the registration.
Registration data.
Activator.
The component registration's resolve pipeline builder.
Services provided by the registration.
Optional; target registration.
An IComponentRegistration.
Thrown if or is .
Register a component in the component registry. This helper method is necessary
in order to execute OnRegistered hooks and respect PreserveDefaults.
Hoping to refactor this out.
Component registry to make registration in.
Registration builder with data for new registration.
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}' is not assignable to service '{1}'..
Data structure used to construct registrations.
The most specific type to which instances of the registration
can be cast.
Activator builder type.
Registration style type.
Initializes a new instance of the class.
The default service.
The activator data.
The registration style.
Gets the activator data.
Gets the registration style.
Gets the registration data.
Gets the resolve pipeline builder, that can be used to add middleware to the pipeline.
Configure the component so that instances are never disposed by the container.
A registration builder allowing further configuration of the component.
Configure the component so that instances that support IDisposable are
disposed by the container (default).
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
gets a new, unique instance (default).
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
gets the same, shared instance.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a single ILifetimeScope gets the same, shared instance. Dependent components in
different lifetime scopes will get different instances.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve() within
a ILifetimeScope tagged with any of the provided tags value gets the same, shared instance.
Dependent components in lifetime scopes that are children of the tagged scope will
share the parent's instance. If no appropriately tagged scope can be found in the
hierarchy an is thrown.
Tag applied to matching lifetime scopes.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
The service type provided by the component.
Key to associate with the component.
A registration builder allowing further configuration of the component.
Configure the component so that every dependent component or call to Resolve()
within a ILifetimeScope created by an owned instance gets the same, shared instance.
Dependent components in lifetime scopes that are children of the owned instance scope will
share the parent's instance. If no appropriate owned instance scope can be found in the
hierarchy an is thrown.
Key to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide. The generic parameter(s) to As()
will be exposed as TypedService instances.
Service type.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide. The generic parameter(s) to As()
will be exposed as TypedService instances.
Service type.
Service type.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide. The generic parameter(s) to As()
will be exposed as TypedService instances.
Service type.
Service type.
Service type.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide.
Service types to expose.
A registration builder allowing further configuration of the component.
Configure a single service that the component will provide.
Service type to expose.
A registration builder allowing further configuration of the component.
Configure the services that the component will provide.
Services to expose.
A registration builder allowing further configuration of the component.
Configure a single service that the component will provide.
Service to expose.
A registration builder allowing further configuration of the component.
Provide a textual name that can be used to retrieve the component.
Named service to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Provide a textual name that can be used to retrieve the component.
Named service to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Provide a key that can be used to retrieve the component.
Key to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Provide a key that can be used to retrieve the component.
Key to associate with the component.
The service type provided by the component.
A registration builder allowing further configuration of the component.
Add a handler for the Preparing event. This event allows manipulating of the parameters
that will be provided to the component.
The event handler.
A registration builder allowing further configuration of the component.
Add a handler for the Activating event.
The event handler.
A registration builder allowing further configuration of the component.
Add a handler for the Activated event.
The event handler.
A registration builder allowing further configuration of the component.
Configure the component so that any properties whose types are registered in the
container and follow specific criteria will be wired to instances of the appropriate service.
Selector to determine which properties should be injected.
Determine if circular dependencies should be allowed or not.
A registration builder allowing further configuration of the component.
Associates data with the component.
Key by which the data can be located.
The data value.
A registration builder allowing further configuration of the component.
Associates data with the component.
The extended properties to associate with the component.
A registration builder allowing further configuration of the component.
Associates data with the component.
A type with properties whose names correspond to the
property names to configure.
The action used to configure the metadata.
A registration builder allowing further configuration of the component.
Data common to all registrations made in the container, both direct (IComponentRegistration)
and dynamic (IRegistrationSource).
Initializes a new instance of the class.
The default service that will be used if no others
are added.
Gets the services explicitly assigned to the component.
Add multiple services for the registration, overriding the default.
The services to add.
If an empty collection is specified, this will still
clear the default service.
Add a service to the registration, overriding the default.
The service to add.
Gets or sets the instance ownership assigned to the component.
Gets or sets the lifetime assigned to the component.
Gets or sets the sharing mode assigned to the component.
Gets the extended properties assigned to the component.
Gets or sets the options for the registration.
Gets or sets the callback used to register this component.
A that contains the delegate
used to register this component with an .
Copies the contents of another RegistrationData object into this one.
The data to copy.
When true, the default service
will be changed to that of the other.
Thrown if is .
Empties the configured services.
Adds registration syntax for less commonly-used features.
These features are in this namespace because they will remain accessible to
applications originally written against Autofac 1.4. In Autofac 2, this functionality
is implicitly provided and thus making explicit registrations is rarely necessary.
Registers a factory delegate.
Container builder.
Factory type to generate.
Registration builder allowing the registration to be configured.
Factory delegates are provided automatically in Autofac 2,
and this method is generally not required.
Registers a factory delegate.
Container builder.
Factory type to generate.
The service that the delegate will return instances of.
Registration builder allowing the registration to be configured.
Factory delegates are provided automatically in Autofac 2, and
this method is generally not required.
Registers a factory delegate.
The type of the delegate.
Container builder.
The service that the delegate will return instances of.
Registration builder allowing the registration to be configured.
Factory delegates are provided automatically in Autofac 2,
and this method is generally not required.
Registers a factory delegate.
The type of the delegate.
Container builder.
Registration builder allowing the registration to be configured.
Factory delegates are provided automatically in Autofac 2,
and this method is generally not required.
Changes the parameter mapping mode of the supplied delegate type to match
parameters by name.
Factory delegate type.
Activator data type.
Registration style.
Registration to change parameter mapping mode of.
Registration builder allowing the registration to be configured.
Thrown if is .
Changes the parameter mapping mode of the supplied delegate type to match
parameters by position.
Factory delegate type.
Activator data type.
Registration style.
Registration to change parameter mapping mode of.
Registration builder allowing the registration to be configured.
Thrown if is .
Changes the parameter mapping mode of the supplied delegate type to match
parameters by type.
Factory delegate type.
Activator data type.
Registration style.
Registration to change parameter mapping mode of.
Registration builder allowing the registration to be configured.
Thrown if is .
Extension methods for controlling and accessing registration order.
Gets the registration order value from the registration.
The registration.
The original registration order value.
Indicates that a registration should inherit its registration order from another registration.
The limit type.
The activator data type.
The registration style type.
The registration builder.
The source registration to take the order from.
The registration builder.
An activator builder with no parameters.
Initializes a new instance of the class.
The activator to return.
Gets the activator.
Registration style for individual components.
Gets or sets the ID used for the registration.
Gets the handlers to notify of the component registration event.
Gets or sets a value indicating whether default registrations should be preserved.
By default, new registrations override existing registrations as defaults.
If set to true, new registrations will not change existing defaults.
Gets or sets the component upon which this registration is based.
Helper functions for starting 'startable' components.
Executes the startable and auto-activate components in a context.
The set of properties used during component registration.
The in which startable services should execute.
Used to build an from component registrations.
var builder = new ContainerBuilder();
builder.RegisterType<Logger>()
.As<ILogger>()
.SingleInstance();
builder.Register(c => new MessageHandler(c.Resolve<ILogger>()));
var container = builder.Build();
// resolve components from container...
Most functionality is accessed
via extension methods in .
Initializes a new instance of the class.
Initializes a new instance of the class.
The properties used during component registration.
Initializes a new instance of the class.
The builder to use for building the underlying .
Initializes a new instance of the class.
The properties used during component registration.
The builder to use for building the underlying .
Gets the builder to use for building the underlying .
Gets the set of properties used during component registration.
An that can be used to share
context across registrations.
Register a callback that will be invoked when the container is configured.
This is primarily for extending the builder syntax.
Callback to execute.
Register a callback that will be invoked when the container (or lifetime scope) is built.
Callback to execute.
The instance to continue registration calls.
The argument to the registered build callback will be an instance of the derived if this
builder is being used to build a fresh container, or an if it's being used to
create custom registrations for a new lifetime scope.
Create a new container with the component registrations that have been made.
Options that influence the way the container is initialised.
Build can only be called once per
- this prevents ownership issues for provided instances.
Build enables support for the relationship types that come with Autofac (e.g.
Func, Owned, Meta, Lazy, IEnumerable.) To exclude support for these types,
first create the container, then call Update() on the builder.
A new container with the configured component registrations.
Configure an existing registry with the component registrations
that have been made. Primarily useful in dynamically adding registrations
to a child lifetime scope.
Update can only be called once per
- this prevents ownership issues for provided instances.
An existing registry to make the registrations in.
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 Build() or Update() can only be called once on a ContainerBuilder..
Looks up a localized string similar to An error occurred while attempting to automatically activate registration '{0}'. See the inner exception for information on the source of the failure..
Extensions to the container to provide convenience methods for tracing.
Subscribes a diagnostic tracer to Autofac events.
The container with the diagnostics to which you want to subscribe.
A diagnostic tracer that will be subscribed to the lifetime scope's diagnostic source.
This is a convenience method that attaches the to the
associated with the . If you
have an event listener that isn't a you can
use standard semantics to subscribe to the events
with your custom listener.
Subscribes a diagnostic tracer to Autofac events.
The type of diagnostic tracer that will be subscribed to the lifetime scope's diagnostic source.
The container with the diagnostics to which you want to subscribe.
The diagnostic tracer that was created and attached to the diagnostic source. Use
this instance to enable or disable the messages that should be handled.
This is a convenience method that attaches a tracer to the
associated with the . If you
have an event listener that isn't a you can
use standard semantics to subscribe to the events
with your custom listener.
Fired when the activation process for a new instance is complete.
Initializes a new instance of the class.
The context.
The component.
The parameters.
The instance.
The service being resolved.
Gets the service being resolved.
Gets the context in which the activation occurred.
Gets the component providing the instance.
Gets the paramters provided when resolved.
Gets the instance that will be used to satisfy the request.
Fired after the construction of an instance but before that instance
is shared with any other or any members are invoked on it.
Initializes a new instance of the class.
The context.
The service.
The component.
The parameters.
The instance.
Gets the service being resolved.
Gets the context in which the activation occurred.
Gets the component providing the instance.
Gets or sets the instance that will be used to satisfy the request.
The instance can be replaced if needed, e.g. by an interface proxy.
The instance can be replaced if needed, e.g. by an interface proxy.
The object to use instead of the activated instance.
Gets the parameters supplied to the activator.
Provides default property selector that applies appropriate filters to ensure only
public settable properties are selected (including filtering for value types and indexed
properties).
Initializes a new instance of the class
that provides default selection criteria.
Determines if values should be preserved or not.
Gets a value indicating whether the value should be set if the value is already
set (ie non-null).
Gets an instance of DefaultPropertySelector that will cause values to be overwritten.
Gets an instance of DefaultPropertySelector that will preserve any values already set.
Provides default filtering to determine if property should be injected by rejecting
non-public settable properties.
Property to be injected.
Instance that has the property to be injected.
Whether property should be injected.
Activate instances using a delegate.
Initializes a new instance of the class.
The most specific type to which activated instances can be cast.
Activation delegate.
Invokes the delegate and returns the instance.
Context in which to activate instances.
Parameters to the instance.
The activated instance.
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 A delegate registered to create instances of '{0}' returned null..
Base class for instance activators.
Initializes a new instance of the class.
Most derived type to which instances can be cast.
Gets the most specific type that the component instances are known to be castable to.
Gets a string representation of the activator.
A string describing the activator.
Asserts that the activator has not been disposed.
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 Instances cannot be created by this activator as it has already been disposed..
Provides a pre-constructed instance.
Initializes a new instance of the class.
The instance to provide.
Gets or sets a value indicating whether the activator disposes the instance that it holds.
Necessary because otherwise instances that are never resolved will never be
disposed.
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 provided instance of '{0}' has already been used in an activation request. Did you combine a provided instance with non-root/single-instance lifetime/sharing?.
Supplies values based on the target parameter type.
Returns true if the parameter is able to provide a value to a particular site.
Constructor, method, or property-mutator parameter.
The component context in which the value is being provided.
If the result is true, the valueProvider parameter will
be set to a function that will lazily retrieve the parameter value. If the result is false,
will be set to null.
True if a value can be supplied; otherwise, false.
Thrown if or is .
Provide helper methods for injecting property values.
Name of the parameter containing the instance type provided when resolving an injected service.
Inject properties onto an instance, filtered by a property selector.
The component context to resolve dependencies from.
The instance to inject onto.
The property selector.
The set of parameters for the resolve that can be used to satisfy injectable properties.
Represents the outcome of a single bind attempt by a .
Initializes a new instance of the class for a successful bind.
The binder that generated this binding.
The instance factory.
The set of value-retrieval functions.
Initializes a new instance of the class, for an unsuccessful bind.
The binder that generated this binding.
The first parameter that prevented binding.
Initializes a new instance of the class for a successful bind.
The binder that generated this binding.
The instance factory.
The set of value-retrieval functions.
Initializes a new instance of the class, for an unsuccessful bind.
The binder that generated this binding.
The first parameter that prevented binding.
Gets the binder that created this binding.
Gets the constructor on the target type. The actual constructor used
might differ, e.g. if using a dynamic proxy.
Gets the total number of arguments for the bound constructor.
Gets a value indicating whether the binding is valid.
Invoke the constructor with the parameter bindings.
The constructed instance.
Gets a description of the constructor parameter binding.
Returns a System.String that represents the current System.Object.
A System.String that represents the current System.Object.
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 Bound constructor '{0}'..
Looks up a localized string similar to The binding cannot be instantiated: {0}.
Looks up a localized string similar to An exception was thrown while invoking the constructor '{0}' on type '{1}'..
Looks up a localized string similar to Cannot resolve parameter '{1}' of constructor '{0}'..
Provides the functionality to bind a single constructor at resolve time.
Initializes a new instance of the class.
The constructor.
Gets the constructor this binder is responsible for binding.
Gets the set of parameters to bind against.
Gets the number of parameters.
Binds the set of parameters to the constructor. indicates success.
The set of all parameters.
The current component context.
The bind result.
Finds constructors that match a finder function.
Initializes a new instance of the class.
Default to selecting all public constructors.
Initializes a new instance of the class.
The finder function.
Finds suitable constructors on the target type.
Type to search for constructors.
Suitable constructors.
Provides parameters that have a default value, set with an optional parameter
declaration in C# or VB.
Returns true if the parameter is able to provide a value to a particular site.
Constructor, method, or property-mutator parameter.
The component context in which the value is being provided.
If the result is true, the parameter will
be set to a function that will lazily retrieve the parameter value. If the result is ,
will be set to .
if a value can be supplied; otherwise, .
Thrown if is .
Find suitable constructors from which to select.
Finds suitable constructors on the target type.
Type to search for constructors.
Suitable constructors.
Selects the best constructor from a set of available constructors.
Selects the best constructor from the available constructors.
Available constructors.
Parameters to the instance being resolved.
The best constructor.
Selects a constructor based on its signature.
Initializes a new instance of the class.
Signature to match.
Selects the best constructor from the available constructors.
Available constructors.
Parameters to the instance being resolved.
The best constructor.
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 At least one binding must be provided in order to select a constructor..
Looks up a localized string similar to The required constructor on type '{0}' with signature '{1}' is unavailable..
Looks up a localized string similar to More than one constructor matches the signature '{0}'..
Selects the constructor with the most parameters.
Selects the best constructor from the available constructors.
Available constructors.
Parameters to the instance being resolved.
The best constructor.
A single unambiguous match could not be chosen.
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 Cannot choose between multiple constructors with equal length {0} on type '{1}'. Select the constructor explicitly, with the UsingConstructor() configuration method, when the component is registered..
Exception thrown when no suitable constructors could be found on a type.
Initializes a new instance of the class.
The whose constructor was not found.
Initializes a new instance of the class.
The whose constructor was not found.
Exception message.
Initializes a new instance of the class.
The whose constructor was not found.
The inner exception.
Initializes a new instance of the class.
The whose constructor was not found.
Exception message.
The inner exception.
Gets the type without found constructors.
A that was processed by an
or similar mechanism and was determined to have no available constructors.
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 No accessible constructors were found for the type '{0}'..
Uses reflection to activate instances of a type.
Initializes a new instance of the class.
Type to activate.
Constructor finder.
Constructor selector.
Parameters configured explicitly for this instance.
Properties configured explicitly for this instance.
Gets the constructor finder.
Gets the constructor selector.
Activate an instance in the provided context.
Context in which to activate instances.
Parameters to the instance.
The activated instance.
The context parameter here should probably be ILifetimeScope in order to reveal Disposer,
but will wait until implementing a concrete use case to make the decision.
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 constructor selector provided by '{0}' selected a binding that cannot be instantiated. Selectors must return a constructor where 'CanInstantiate' is true..
Looks up a localized string similar to No constructors on type '{0}' can be found with the constructor finder '{1}'..
Looks up a localized string similar to None of the constructors found with '{0}' on type '{1}' can be invoked with the available services and parameters:{2}.
Provides a property selector that applies a filter defined by a delegate.
Initializes a new instance of the class
that invokes a delegate to determine selection.
Delegate to determine whether a property should be injected.
Finds suitable properties to inject.
Provides filtering to determine if property should be injected.
Property to be injected.
Instance that has the property to be injected.
Whether property should be injected.
Service used as a "flag" to indicate a particular component should be
automatically activated on container build.
Gets the service description.
Always returns AutoActivate.
Determines whether the specified is equal to the current .
The to compare with the current .
if the specified is not
and is an ; otherwise, .
All services of this type are considered "equal".
Serves as a hash function for a particular type.
A hash code for the current . Always 0 for this type.
All services of this type are considered "equal" and use the same hash code.
Information about the ocurrence of a component being registered
with a container.
Gets the into which the registration was made.
Gets the component registration.
Initializes a new instance of the class.
The into which the registration was made.
The component registration.
Extension methods for .
For components registered instance-per-matching-lifetime-scope, retrieves the set
of lifetime scope tags to match.
The to query for matching lifetime scope tags.
If the component is registered instance-per-matching-lifetime-scope, this method returns
the set of matching lifetime scope tags. If the component is singleton, instance-per-scope,
instance-per-dependency, or otherwise not an instance-per-matching-lifetime-scope
component, this method returns an empty enumeration.
Provides access to the registration's pipeline builder, allowing custom middleware to be added.
The component registration.
An action that can configure the registration's pipeline.
Attaching to this event after a component registration
has already been built will throw an exception.
Base class for parameters that provide a constant value.
Gets the value of the parameter.
Initializes a new instance of the class.
The constant parameter value.
A predicate used to locate the parameter that should be populated by the constant.
Returns true if the parameter is able to provide a value to a particular site.
Constructor, method, or property-mutator parameter.
The component context in which the value is being provided.
If the result is true, the valueProvider parameter will
be set to a function that will lazily retrieve the parameter value. If the result is false,
will be set to null.
True if a value can be supplied; otherwise, false.
Standard container implementation.
Initializes a new instance of the class.
The registry of components.
Begin a new sub-scope. Instances created via the sub-scope
will be disposed along with it.
A new lifetime scope.
Begin a new sub-scope. Instances created via the sub-scope
will be disposed along with it.
The tag applied to the .
A new lifetime scope.
Begin a new nested scope, with additional components available to it.
Component instances created via the new scope
will be disposed along with it.
Action on a
that adds component registrations visible only in the new scope.
A new lifetime scope.
Begin a new nested scope, with additional components available to it.
Component instances created via the new scope
will be disposed along with it.
The tag applied to the .
Action on a
that adds component registrations visible only in the new scope.
A new lifetime scope.
Gets the disposer associated with this container. Instances can be associated
with it manually if required.
Gets the tag applied to the lifetime scope.
The tag applied to this scope and the contexts generated when
it resolves component dependencies.
Fired when a new scope based on the current scope is beginning.
Fired when this scope is ending.
Fired when a resolve operation is beginning in this scope.
Gets associated services with the components that provide them.
Releases unmanaged and - optionally - managed resources.
true to release both managed and unmanaged resources; false to release only unmanaged resources.
Gets the service object of the specified type.
An object that specifies the type of service object
to get.
A service object of type .-or- null if there is
no service object of type .
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 container's self-registration of context interfaces should never be activated as it is hard-wired into the LifetimeScope class..
Base exception type thrown whenever the dependency resolution process fails. This is a fatal
exception, as Autofac is unable to 'roll back' changes to components that may have already
been made during the operation. For example, 'on activated' handlers may have already been
fired, or 'single instance' components partially constructed.
Initializes a new instance of the class.
The serialisation info.
The serialisation streaming context.
Initializes a new instance of the class.
The message.
Initializes a new instance of the class.
The message.
The inner exception.
Maintains a set of objects to dispose, and disposes them in the reverse order
from which they were added when the Disposer is itself disposed.
Contents all implement IDisposable or IAsyncDisposable.
Releases unmanaged and - optionally - managed resources.
true to release both managed and unmanaged resources; false to release only unmanaged resources.
Adds an object to the disposer, where that object only implements IAsyncDisposable. When the disposer is
disposed, so will the object be.
This is not typically recommended, and you should implement IDisposable as well.
The instance.
If this Disposer is disposed of using a synchronous Dispose call, that call will throw an exception.
Adds an object to the disposer. When the disposer is
disposed, so will the object be.
The instance.
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 Disposer object has already been Disposed, so no items can be added to it..
Looks up a localized string similar to AUTOFAC: A synchronous Dispose has been attempted, but the tracked object of type '{0}' only implements IAsyncDisposable. This will result in an efficient blocking dispose. Consider either implementing IDisposable on '{0}' or disposing of the scope/container with DisposeAsync..
Fired when the activation process for a new instance is complete.
Gets the service being resolved.
Gets the context in which the activation occurred.
Gets the component providing the instance.
Gets the paramters provided when resolved.
Gets the instance that will be used to satisfy the request.
Fired after the construction of an instance but before that instance
is shared with any other or any members are invoked on it.
Gets the service being resolved.
Gets the context in which the activation occurred.
Gets the component providing the instance.
Gets the instance that will be used to satisfy the request.
The instance can be replaced if needed, e.g. by an interface proxy.
The object to use instead of the activated instance.
Gets the parameters supplied to the activator.
Locates the lifetime to which instances of a component should be attached.
Given the most nested scope visible within the resolve operation, find
the scope for the component.
The most nested visible scope.
The scope for the component.
Describes a logical component within the container.
Gets a unique identifier for this component (shared in all sub-contexts.)
This value also appears in Services.
Gets the activator used to create instances.
Gets the lifetime associated with the component.
Gets a value indicating whether the component instances are shared or not.
Gets a value indicating whether the instances of the component should be disposed by the container.
Gets the services provided by the component.
Gets additional data associated with the component.
Gets the component registration upon which this registration is based.
Gets the resolve pipeline for the component.
Gets the options for the registration.
Provides an event that will be invoked just before a pipeline is built, and can be used to add additional middleware
at that point.
Attaching to this event after a component registration
has already been built will throw an exception.
Builds the resolve pipeline.
The available services.
Provides component registrations according to the services they provide.
Gets the set of properties used during component registration.
An that can be used to share
context across registrations.
Gets the set of registered components.
Gets the registration sources that are used by the registry.
Gets the set of service middleware sources that are used by the registry.
Gets a value indicating whether the registry contains its own components.
True if the registry contains its own components; false if it is forwarding
registrations from another external registry.
This property is used when walking up the scope tree looking for
registrations for a new customized scope.
Attempts to find a default registration for the specified service.
The service to look up.
The default registration for the service.
True if a registration exists.
Attempts to find a default service registration for the specified service.
The service to look up.
The default registration for the service.
True if a registration exists.
Determines whether the specified service is registered.
The service to test.
True if the service is registered.
Gets the set of custom service middleware for the specified service.
The service to look up.
The set of custom service middleware.
Selects from the available registrations after ensuring that any
dynamic registration sources that may provide
have been invoked.
The service for which registrations are sought.
Registrations supporting .
Selects from the available service registrations after ensuring that any
dynamic registration sources that may provide
have been invoked.
The service for which registrations are sought.
Service registrations supporting .
Defines an interface for accessing the set of services available during pipeline build time.
Selects from the available registrations after ensuring that any
dynamic registration sources that may provide
have been invoked.
The service for which registrations are sought.
Registrations supporting .
Attempts to find a default registration for the specified service.
The service to look up.
The default registration for the service.
True if a registration exists.
Determines whether the specified service is registered.
The service to test.
True if the service is registered.
Provided on an object that will dispose of other objects when it is
itself disposed.
Adds an object to the disposer. When the disposer is
disposed, so will the object be.
The instance.
Adds an object to the disposer, where that object implements IAsyncDisposable. When the disposer is
disposed, so will the object be.
You should most likely implement IDisposable as well, and call instead of this method.
The instance.
If the provided object only implements IAsyncDisposable, and the is disposed of using a synchronous Dispose call,
that call will throw an exception when it attempts to dispose of the provided instance.
Activates component instances.
Allows an implementation to add middleware to a registration's resolve pipeline.
Provides access to the set of all available services.
The registration's pipeline builder.
Gets the most specific type that the component instances are known to be castable to.
Represents a set of components and related functionality
packaged together.
Apply the module to the component registry.
Component registry to apply configuration to.
Support simple definition of implicit relationships such as .
Initializes a new instance of the class.
The implicit type. Must be generic with only one type parameter.
Gets the description of the registration source.
Resolves an instance of the implicit type.
The child type used in the implicit type.
A component context to resolve services.
A resolve request.
An implicit type instance.
Allows hooking into the registration pipeline of the registration source, useful for such things as marking a registration as externally owned.
The registration builder.
The updated registration builder.
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 Type must have a single generic parameter.
Looks up a localized string similar to Type must be generic.
Determines when instances supporting IDisposable are disposed.
The lifetime scope does not dispose the instances.
The instances are disposed when the lifetime scope is disposed.
Determines whether instances are shared within a lifetime scope.
Each request for an instance will return a new object.
Each request for an instance will return the same object.
Allows registrations to be made on-the-fly when unregistered
services are requested (lazy registrations.)
Retrieve registrations for an unregistered service, to be used
by the container.
The service that was requested.
A function that will return existing registrations for a service.
Registrations providing the service.
If the source is queried for service s, and it returns a component that implements both s and s', then it
will not be queried again for either s or s'. This means that if the source can return other implementations
of s', it should return these, plus the transitive closure of other components implementing their
additional services, along with the implementation of s. It is not an error to return components
that do not implement .
Gets a value indicating whether the registrations provided by this source are 1:1 adapters on top
of other components (e.g., Meta, Func, or Owned).
Interface supported by services that carry type information.
Gets the type of the service.
The type of the service.
Return a new service of the same kind, but carrying
as the .
The new service type.
A new service with the service type.
Defines a nested structure of lifetimes.
Gets the root of the sharing hierarchy.
Gets the parent of this node of the hierarchy, or null.
Try to retrieve a shared instance based on a GUID key.
Key to look up.
The instance that has the specified key.
true if the key was found; otherwise, false.
Try to retrieve a shared instance based on a primary GUID key and
possible secondary qualifying GUID key.
Key to look up.
Secondary key to look up, to better identify an instance that wraps around another instance
or is otherwise "namespaced" by it.
The instance that has the specified keys.
true if the key was found; otherwise, false.
Creates a shared instance with a GUID key.
Key.
A function that will create the instance when called.
The shared instance.
Creates a shared instance with a primary GUID key and
possible secondary qualifying GUID key.
Key.
Secondary key, to better identify an instance that wraps around another instance
or is otherwise "namespaced" by it.
A function that will create the instance when called.
The shared instance.
Identifies a service using a key in addition to its type.
Initializes a new instance of the class.
Key of the service.
Type of the service.
Gets the key of the service.
The key of the service.
Gets the type of the service.
The type of the service.
Gets a human-readable description of the service.
The description.
Indicates whether the current object is equal to another object of the same type.
An object to compare with this object.
true if the current object is equal to the parameter; otherwise, false.
Determines whether the specified is equal to the current .
The to compare with the current .
true if the specified is equal to the current ; otherwise, false.
Serves as a hash function for a particular type.
A hash code for the current .
Return a new service of the same kind, but carrying
as the .
The new service type.
A new service with the service type.
Attaches the instance's lifetime to the current lifetime scope.
Gets the singleton instance of the behaviour.
Given the most nested scope visible within the resolve operation, find
the scope for the component.
The most nested visible scope.
The scope for the component.
Lifetime scope implementation.
Protects shared instances from concurrent access. Other members and the base class are threadsafe.
Gets the id of the lifetime scope self-registration.
The tag applied to root scopes when no other tag is specified.
Initializes a new instance of the class.
The tag applied to the .
Components used in the scope.
Parent scope.
Initializes a new instance of the class.
The tag applied to the .
Components used in the scope.
Initializes a new instance of the class.
Components used in the scope.
Begin a new anonymous sub-scope. Instances created via the sub-scope
will be disposed along with it.
A new lifetime scope.
Begin a new tagged sub-scope. Instances created via the sub-scope
will be disposed along with it.
The tag applied to the .
A new lifetime scope.
Gets the to which
trace events should be written.
Begin a new anonymous sub-scope, with additional components available to it.
Component instances created via the new scope
will be disposed along with it.
Action on a
that adds component registrations visible only in the new scope.
A new lifetime scope.
IContainer cr = // ...
using (var lifetime = cr.BeginLifetimeScope(builder => {
builder.RegisterType<Foo>();
builder.RegisterType<Bar>().As<IBar>(); })
{
var foo = lifetime.Resolve<Foo>();
}
Begin a new tagged sub-scope, with additional components available to it.
Component instances created via the new scope
will be disposed along with it.
The tag applied to the .
Action on a
that adds component registrations visible only in the new scope.
A new lifetime scope.
IContainer cr = // ...
using (var lifetime = cr.BeginLifetimeScope("unitOfWork", builder => {
builder.RegisterType<Foo>();
builder.RegisterType<Bar>().As<IBar>(); })
{
var foo = lifetime.Resolve<Foo>();
}
Creates and setup the registry for a child scope.
The tag applied to the .
Action on a
that adds component registrations visible only in the child scope.
Registry to use for a child scope.
It is the responsibility of the caller to make sure that the registry is properly
disposed of. This is generally done by adding the registry to the
property of the child scope.
Gets the parent of this node of the hierarchy, or null.
Gets the root of the sharing hierarchy.
Gets the disposer associated with this container. Instances can be associated
with it manually if required.
Gets the tag applied to the lifetime scope.
The tag applied to this scope and the contexts generated when
it resolves component dependencies.
Gets the services associated with the components that provide them.
Releases unmanaged and - optionally - managed resources.
true to release both managed and unmanaged resources; false to release only unmanaged resources.
Gets a value indicating whether this or any of the parent disposables have been disposed.
true if this instance of any of the parent instances have been disposed.
Gets the service object of the specified type.
An object that specifies the type of service object
to get.
A service object of type .-or- null if there is
no service object of type .
Fired when a new scope based on the current scope is beginning.
Fired when this scope is ending.
Fired when a resolve operation is beginning in this scope.
Describes when a lifetime scope is beginning.
Initializes a new instance of the class.
The lifetime scope that is beginning.
Gets the lifetime scope that is beginning.
Describes when a lifetime scope is ending.
Initializes a new instance of the class.
The lifetime scope that is ending.
Gets the lifetime scope that is ending.
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 tag '{0}' has already been assigned to a parent lifetime scope. If you are using Owned<T> this indicates you may have a circular dependency chain..
Looks up a localized string similar to Instances cannot be resolved and nested lifetimes cannot be created from this LifetimeScope as it (or one of its parent scopes) has already been disposed..
Looks up a localized string similar to The constructor of type '{0}' attempted to create another instance of itself. This is not permitted because the service is configured to only allowed a single instance per lifetime scope..
Attaches the component's lifetime to scopes matching a supplied expression.
Initializes a new instance of the class.
The tags applied to matching scopes.
Gets the list of lifetime scope tags to match.
An of object tags to match
when searching for the lifetime scope for the component.
Given the most nested scope visible within the resolve operation, find
the scope for the component.
The most nested visible scope.
The scope for the component.
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 No scope with a tag matching '{0}' is visible from the scope in which the instance was requested.
If you see this during execution of a web application, it generally indicates that a component registered as per-HTTP request is being requested by a SingleInstance() component (or a similar scenario). Under the web integration always request dependencies from the dependency resolver or the request lifetime scope, never from the container itself..
Well-known tags used in setting up matching lifetime scopes.
Tag used in setting up per-request lifetime scope registrations
(e.g., per-HTTP-request or per-API-request).
Attaches the component's lifetime to the root scope.
Gets the singleton instance of the behaviour.
Given the most nested scope visible within the resolve operation, find
the scope for the component.
The most nested visible scope.
The scope for the component.
A property identified by name. When applied to a reflection-based
component, the name will be matched against property names.
Gets the name of the property.
Initializes a new instance of the class.
The name of the property.
The property value.
Used in order to provide a value to a constructor parameter or property on an instance
being created by the container.
Not all parameters can be applied to all sites.
Returns true if the parameter is able to provide a value to a particular site.
Constructor, method, or property-mutator parameter.
The component context in which the value is being provided.
If the result is true, the valueProvider parameter will
be set to a function that will lazily retrieve the parameter value. If the result is false,
will be set to null.
True if a value can be supplied; otherwise, false.
Fired before the activation process to allow parameters to be changed or an alternative
instance to be provided.
Initializes a new instance of the class.
The service being resolved.
The context.
The component.
The parameters.
Gets the service being resolved.
Gets the context in which the activation is occurring.
Gets the component providing the instance being activated.
Gets or sets the parameters supplied to the activator.
A service was requested that cannot be provided by the container. To avoid this exception, either register a component
to provide the required service, check for service registration using IsRegistered(), or use the ResolveOptional()
method to resolve an optional dependency.
This exception is fatal. See for more information.
Initializes a new instance of the class.
The service.
Initializes a new instance of the class.
The service.
The inner exception.
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 requested service '{0}' has not been registered. To avoid this exception, either register a component to provide the service, check for service registration using IsRegistered(), or use the ResolveOptional() method to resolve an optional dependency..
Event arguments for the event.
Initializes a new instance of the class.
The registration.
The pipeline builder.
Gets the component registration whose pipeline is being built.
Gets the pipeline builder for the registration. Add middleware to the builder to add to the component behaviour.
Describes a logical component within the container.
Defines the options copied from a target registration onto this one.
Initializes a new instance of the class.
The registration id.
The component activator.
The lifetime for activated instances.
The sharing setting for the registration.
The ownership setting for the registration.
The set of services provided by the registration.
Any metadata associated with the registration.
The target/inner registration.
Contains options for the registration.
Initializes a new instance of the class.
Unique identifier for the component.
Activator used to activate instances.
Determines how the component will be associated with its lifetime.
Whether the component is shared within its lifetime scope.
Whether the component instances are disposed at the end of their lifetimes.
Services the component provides.
Data associated with the component.
Contains options for the registration.
Initializes a new instance of the class.
Unique identifier for the component.
Activator used to activate instances.
Determines how the component will be associated with its lifetime.
Whether the component is shared within its lifetime scope.
Whether the component instances are disposed at the end of their lifetimes.
The resolve pipeline builder for the registration.
Services the component provides.
Data associated with the component.
The additional registration options.
Initializes a new instance of the class.
Unique identifier for the component.
Activator used to activate instances.
Determines how the component will be associated with its lifetime.
Whether the component is shared within its lifetime scope.
Whether the component instances are disposed at the end of their lifetimes.
The resolve pipeline builder for the registration.
Services the component provides.
Data associated with the component.
The component registration upon which this registration is based.
Registration options.
Gets the component registration upon which this registration is based.
If this registration was created directly by the user, returns this.
Gets a unique identifier for this component (shared in all sub-contexts.)
This value also appears in Services.
Gets the activator for the registration.
Gets the lifetime associated with the component.
Gets information about whether the component instances are shared or not.
Gets information about whether the instances of the component should be disposed by the container.
Gets the services provided by the component.
Gets additional data associated with the component.
Gets the options for the registration.
Populates the resolve pipeline with middleware based on the registration, and builds the pipeline.
The known set of all services.
The registration's pipeline builder (with user-added middleware already in it).
The built pipeline.
A derived implementation can use this to add additional middleware, or return a completely different pipeline if required.
Describes the component in a human-readable form.
A description of the component.
Internal Extension methods for component registrations.
Gets a value indicating whether a given registration is adapting another registration.
The component registration.
True if adapting; false otherwise.
Wraps a component registration, switching its lifetime.
Initializes a new instance of the class.
The inner registration.
The enforced lifetime.
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 Component pipeline has not yet been built..
Looks up a localized string similar to Component pipeline has already been built, and cannot be modified..
Looks up a localized string similar to Not Built.
Looks up a localized string similar to Activator = {0}, Services = [{1}], Lifetime = {2}, Sharing = {3}, Ownership = {4}, Pipeline = {5}.
Maps services onto the components that provide them.
The component registry provides services directly from components,
and also uses to generate components
on-the-fly or as adapters for other components. A component registry
is normally used through a , and not
directly by application code.
Initializes a new instance of the class.
The tracker for the registered services.
The properties used during component registration.
Gets the set of properties used during component registration.
An that can be used to share
context across registrations.
Gets the registered components.
Gets the registration sources that are used by the registry.
Gets a value indicating whether the registry contains its own components.
True if the registry contains its own components; false if it is forwarding
registrations from another external registry.
This property is used when walking up the scope tree looking for
registrations for a new customized scope.
Attempts to find a default registration for the specified service.
The service to look up.
The default registration for the service.
True if a registration exists.
Determines whether the specified service is registered.
The service to test.
True if the service is registered.
Selects from the available registrations after ensuring that any
dynamic registration sources that may provide
have been invoked.
The service for which registrations are sought.
Registrations supporting .
Used to build a .
The tracker for the registered services.
Initializes a new instance of the class.
The tracker for the registered services.
The properties used during component registration.
Gets the set of properties used during component registration.
An that can be used to share
context across registrations.
Create a new with all the component registrations that have been made.
A new component registry with the configured component registrations.
Determines whether the specified service is registered.
The service to test.
True if the service is registered.
Register a component.
The component registration.
Register a component.
The component registration.
If true, existing defaults for the services provided by the
component will not be changed.
Fired whenever a component is registered - either explicitly or via a
.
Add a registration source that will provide registrations on-the-fly.
The source to register.
Fired when an is added to the registry.
Keeps track of the status of registered services.
Keeps track of the status of registered services.
External registration sources.
All registrations.
Initializes a new instance of the class.
Fired whenever a component is registered - either explicitly or via a
.
Fired when an is added to the registry.
A wrapper component registration created only to distinguish it from other adapted registrations.
Initializes a new instance of the class.
The service to register for.
The target registration ID.
Provides middleware from a parent component registry.
Initializes a new instance of the class.
The component registry to retrieve middleware from.
Pulls registrations from another component registry.
Excludes most auto-generated registrations - currently has issues with
collection registrations.
Initializes a new instance of the class.
Component registry to pull registrations from.
Retrieve registrations for an unregistered service, to be used
by the container.
The service that was requested.
A function that will return existing registrations for a service.
Registrations providing the service.
Gets a value indicating whether components are adapted from the same logical scope.
In this case because the components that are adapted do not come from the same
logical scope, we must return false to avoid duplicating them.
Used to build a .
Create a new with all the component registrations that have been made.
A new component registry with the configured component registrations.
Gets the set of properties used during component registration.
An that can be used to share
context across registrations.
Register a component.
The component registration.
Register a component.
The component registration.
If true, existing defaults for the services provided by the
component will not be changed.
Fired whenever a component is registered - either explicitly or via a
.
Determines whether the specified service is registered.
The service to test.
True if the service is registered.
Add a registration source that will provide registrations on-the-fly.
The source to register.
Add a source of service middleware that will provide service registrations on-the-fly.
The source to add.
Register a piece of service middleware that will be invoked for all registrations of a service when they are resolved.
The service to register middleware for.
The middleware to register.
The mode of insertion into the pipeline.
Fired when an is added to the registry.
Interface providing fluent syntax for chaining module registrations.
Gets the registrar data.
Add a module to the container.
The module to add.
The to allow
additional chained module registrations.
Keeps track of the status of registered services.
Adds a registration to the list of registered services.
The registration to add.
Indicates whether the defaults should be preserved.
Indicates whether this is an explicitly added registration or that it has been added by a dynamic registration source.
Adds a piece of middleware to a service.
The service to add to.
The middleware.
The insertion mode.
Add a registration source that will provide registrations on-the-fly.
The source to register.
Adds a service middleware source that will provide service middleware on-the-fly.
The source to register.
Fired whenever a component is registered - either explicitly or via an .
Fired when an is added to the registry.
Should be called prior to the construction of a to
indicate that the tracker is complete, and requested service information should no longer be ephemeral.
Gets the registered components.
Gets the registration sources that are used by the registry.
Gets the set of registered service middleware sources.
Gets the set of configured service middleware for a service.
The service to look up.
The set of middleware.
Attempts to find a default service registration for the specified service.
The service to look up.
The default registration for the service.
True if a registration exists.
Selects from the available service registrations after ensuring that any
dynamic registration sources that may provide
have been invoked.
The service for which registrations are sought.
Service registrations supporting .
Interface defining a source of middleware for a service's pipeline.
Called when a service is first resolved; implementations can add middleware to the service using the .
The service being resolved.
Access to the set of available service registrations.
A pipeline builder that can be used to add middleware.
Interface providing fluent syntax for chaining middleware source registrations.
Adds a middleware source to the container.
The middleware source to add.
The to allow additional chained middleware source registrations.
Interface providing fluent syntax for chaining registration source registrations.
Add a registration source to the container.
The registration source to add.
The to allow additional chained registration source registrations.
Basic implementation of the
interface allowing registration of modules into a
in a fluent format.
Initializes a new instance of the class.
The into which registrations will be made.
Thrown if is .
Add a module to the container.
The module to add.
The to allow
additional chained module registrations.
Thrown if is .
Data used by to support customisations to the module registration process.
Initializes a new instance of the class.
The callback for the registrar.
Gets the callback invoked when the collection of modules attached to this registrar are registered.
Defines options for a registration.
No special options; default behaviour.
Indicates that this registration is 'fixed' as the default, ignoring all other registrations when determining the default registration for
a service.
Registrations with this flag will not be decorated.
Registrations with this flag will not be included in any collection resolves (i.e. and other collection types).
Flag combination for composite registrations.
Extension methods for registration options.
Tests whether a given flag (or combined set of flags) is present in the specified
options enumeration.
The option to test.
The flag (or flags) to test for.
True if the specified flag (or flags) are enabled for the registration.
A where the singletons are scoped with the provided .
Initializes a new instance of the class.
The scope to which registrations are restricted.
Basic implementation of the
interface allowing registration of middleware sources into a
in a fluent format.
The into which registrations will be made.
Initializes a new instance of the class.
The into which registrations will be made.
Thrown if is .
Tracks the services known to the registry.
List of implicit default service implementations. Overriding default implementations are appended to the end,
so the enumeration should begin from the end too, and the most default implementation comes last.
List of service implementations coming from sources. Sources have priority over preserve-default implementations.
Implementations from sources are enumerated in preserve-default order, so the most default implementation comes first.
List of explicit service implementations specified with the PreserveExistingDefaults option.
Enumerated in preserve-defaults order, so the most default implementation comes first.
Used for bookkeeping so that the same source is not queried twice (may be null).
Initializes a new instance of the class.
The tracked service.
Gets a value indicating whether the first time a service is requested, initialization (e.g. reading from sources)
happens. This value will then be set to true. Calling many methods on this type before
initialization is an error.
Gets or sets a value representing the current initialization depth. Will always be zero for initialized service blocks.
Gets the known implementations. The first implementation is a default one.
Gets the service pipeline. Will throw if not initialized.
Gets the set of all middleware registered against the service (excluding the default middleware).
Gets a value indicating whether any implementations are known.
Add an implementation for the service.
The component registration.
Whether to preserve the defaults.
Whether the registration originated from a dynamic source.
Use the specified piece of middleware in the service pipeline.
The middleware.
The inserton mode for the pipeline.
Use the multiple specified pieces of middleware in the service pipeline.
The set of middleware.
The insertion mode.
Attempts to access the implementing registration for this service, selecting the correct one based on defaults and all known registrations.
The output registration.
True if a registration was found; false otherwise.
Gets a value indicating whether this service info is initialising.
Gets a value indicating whether there are any sources left to query.
Begin the initialisation process for this service info, given the set of dynamic sources.
The set of sources.
Skip a given source in the set of dynamic sources.
The source to skip.
Dequeue the next registration source.
The source.
Complete initialisation of the service info.
Creates a copy of an uninitialized , preserving existing registrations and custom middleware.
A new service registration info block.
Thrown if the service registration has been initialized already.
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 operation is only valid before the object is initialized..
Looks up a localized string similar to The operation is only valid during initialization..
Looks up a localized string similar to The operation is not valid until the object is initialized..
Looks up a localized string similar to The service pipeline cannot be built until the service has finished initialization..
Defines a middleware source that adds a specific middleware to all services that expose a specific type; this allows middleware
to be added to regular and keyed instances.
Initializes a new instance of the class.
The service type.
The middleware to add.
The insertion mode of the middleware.
Basic implementation of the
interface allowing registration of registration sources into a
in a fluent format.
The into which registrations will be made.
Initializes a new instance of the class.
The into which registrations will be made.
Thrown if is .
Add a registration source to the container.
The registration source to add.
The to allow additional chained registration source registrations.
Thrown if is .
Fired when an is added to the registry.
Initializes a new instance of the class.
The registry to which the source was added.
The source that was added.
Gets the registry to which the source was added.
Gets the source that was added.
Flexible parameter type allows arbitrary values to be retrieved
from the resolution context.
Initializes a new instance of the class.
A predicate that determines which parameters on a constructor will be supplied by this instance.
A function that supplies the parameter value given the context.
Returns true if the parameter is able to provide a value to a particular site.
Constructor, method, or property-mutator parameter.
The component context in which the value is being provided.
If the result is true, the valueProvider parameter will
be set to a function that will lazily retrieve the parameter value. If the result is false,
will be set to null.
True if a value can be supplied; otherwise, false.
Construct a that will match parameters of type
and resolve for those parameters an implementation
registered with the name .
The type of the parameter to match.
The name of the matching service to resolve.
A configured instance.
Construct a that will match parameters of type
and resolve for those parameters an implementation
registered with the key .
The type of the parameter to match.
The key of the matching service to resolve.
A configured instance.
Extension methods for activators.
This shorthand name for the activator is used in exception messages; for activator types
where the limit type generally describes the activator exactly, we use that; for delegate
activators, a variation on the type name is used to indicate this.
The activator instance.
A display name.
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 activation has already been executed: {0}.
Looks up a localized string similar to An exception was thrown while activating {0}..
The interface indicating that an supports dependency tracking. Required by middleware that must understand the dependency tree.
Enter a new dependency chain block where subsequent requests inside the operation are allowed to repeat
registrations from before the block.
A disposable that should be disposed to exit the block.
Gets the modifiable active request stack.
Don't want this exposed to the outside world, but we do want it available in the
,
hence it's internal.
An is a component context that sequences and monitors the multiple
activations that go into producing a single requested object graph.
Gets the active resolve request.
Gets the current lifetime scope of the operation; based on the most recently executed request.
Gets the set of all in-progress requests on the request stack.
Gets the for the operation.
Gets the current request depth.
Gets the that initiated the operation. Other nested requests may have been
issued as a result of this one.
Raised when a resolve request starts.
Raised when the entire operation is complete.
Get or create and share an instance of the requested service in the .
The scope in the hierarchy in which the operation will begin.
The resolve request.
The component instance.
Provides middleware to wrap propagating activator exceptions.
Gets a singleton instance of the middleware.
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 Circular component dependency detected: {0}..
Looks up a localized string similar to Probable circular dependency between factory-scoped components. Chain includes '{0}'.
Common stage. Added to the start of all component pipelines.
Defines the default max resolve depth.
Gets the default instance of .
Initializes a new instance of the class.
The max resolve depth.
Middleware that invokes one of the built-in resolve events, defined by .
Initializes a new instance of the class.
The type of event.
The phase of the pipeine at which the event runs.
The middleware callback to process the event.
Gets the event type represented by this middleware.
Wraps pipeline delegates from the Use* methods in .
Initializes a new instance of the class.
The middleware description.
The pipeline phase.
The callback to execute.
Ensures activated instances are tracked.
Gets the singleton instance of the .
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 Activation phase of the resolve pipeline did not populate the request context's Instance..
Looks up a localized string similar to Unable to resolve the type '{0}' because the lifetime scope it belongs in can't be located. The following services are exposed by this registration:
{1}
Details.
Middleware added by default to the end of all service pipelines that invokes the registration's pipeline.
Gets the singleton instance of this middleware.
Selects the correct activation scope based on the registration's lifetime.
Gets the singleton instance of the .
Checks for a shared instance of the requested registration.
Gets the singleton instance of the middleware.
Middleware that starts startable components.
Gets the singleton instance of the .
Defines the standard set of in-built resolve events, executed by the .
Event type for the OnPreparing event registered by .
Event type for the OnActivating event registered by .
Event type for the OnActivated event registered by .
Event type for the OnRelease event registered by .
Context area for a resolve request.
Initializes a new instance of the class.
The owning resolve operation.
The initiating resolve request.
The lifetime scope.
The to which trace events should be written.
Complete the request, raising any appropriate events.
Defines an executable resolve middleware.
Gets the phase of the resolve pipeline at which to execute.
Invoked when this middleware is executed as part of an active . The middleware should usually call
the method in order to continue the pipeline, unless the middleware fully satisfies the request.
The context for the resolve request.
The method to invoke to continue the pipeline execution; pass this method the argument.
Represents a pipeline that can be invoked to resolve an instance of a service.
Invoke the pipeline to the end, or until an exception is thrown.
The request context.
Provides the ability to build a resolve pipeline from a set of middleware.
Construct a concrete resolve pipeline from this builder.
A built pipeline.
Gets the set of middleware currently registered.
Gets the type of the pipeline this instance will build.
Use a piece of middleware in a resolve pipeline.
The middleware instance.
The insertion mode specifying whether to add at the start or end of the phase.
The same builder instance.
Use a set of multiple, ordered middleware instances in a resolve pipeline.
The set of middleware items to add to the pipelne. The set of middleware must be pre-ordered by phase.
The insertion mode specifying whether to add at the start or end of the phase.
The same builder instance.
Clone this builder, returning a new builder containing the set of middleware already added.
A new builder instance.
Defines a declared piece of middleware in a pipeline builder.
Initializes a new instance of the class.
The middleware that is encapsulated in this declaration.
Gets or sets the next node in a pipeline set.
Gets or sets the previous node in a pipeline set.
Gets the middleware for this declaration.
Gets the declared phase of the middleware.
Provides the modes of insertion when adding middleware to an .
The new middleware should be added at the end of the middleware's declared phase. The added middleware will run after any middleware already added
at the same phase.
The new middleware should be added at the beginning of the middleware's declared phase. The added middleware will run before any middleware
already added at the same phase.
Enumerator for a pipeline builder.
Initializes a new instance of the class.
The first middleware declaration.
Defines the possibles phases of the resolve pipeline.
A resolve pipeline is split into these distinct phases, that control general ordering
of middlewares and allow integrations and consuming code to specify what point in the pipeline to run their middleware.
As a general principle, order between phases is strict, and always executes in the same order, but order within a phase should
not be important for most cases, and handlers should be able to run in any order.
The start of a resolve request. Custom middleware added to this phase executes before circular dependency detection.
In this phase, the lifetime scope selection takes place. If some middleware needs to change the lifetime scope for resolving against,
it happens here (but bear in mind that the configured Autofac lifetime for the registration will take effect).
In this phase, instance decoration will take place (on the way 'out' of the pipeline).
At the end of this phase, if a shared instance satisfies the request, the pipeline will stop executing and exit. Add custom
middleware to this phase to choose your own shared instance.
This phase occurs just before the service pipeline ends (and the registration pipeline is about to start).
This phase occurs at the start of the registration pipeline.
This phase runs just before Activation, is the recommended point at which the resolve parameters should be replaced
(using ).
The Activation phase is the last phase of a pipeline, where a new instance of a component is created.
Defines the possible pipeline types.
A service pipeline. Usually invokes a pipeline when it is finished.
A registration pipeline, used for activating a registration.
Provides the functionality to construct a resolve pipeline.
The pipeline builder is built as a doubly-linked list; each node in that list is a
, that holds the middleware instance, and the reference to the next and previous nodes.
When you call one of the Use* methods, we find the appropriate node in the linked list based on the phase of the new middleware
and insert it into the list.
When you build a pipeline, we walk back through that set of middleware and generate the concrete call chain so that when you execute the pipeline,
we don't iterate over any nodes, but just invoke the built set of methods.
Termination action for the end of pipelines.
Initializes a new instance of the class.
The pipeline type.
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 Cannot add registration middleware in phase '{0}' to a service pipeline. Valid registration middleware phases: [{1}].
Looks up a localized string similar to Cannot add service middleware in phase '{0}' to a registration pipeline. Valid service middleware phases: [{1}].
Looks up a localized string similar to Middleware provided to the UseRange method must be in phase order..
Gets a reference to the owning resolve operation (which might emcompass multiple nested requests).
Gets or sets the lifetime scope that will be used for the activation of any components later in the pipeline.
Avoid resolving instances directly from this scope; they will not be traced as part of the same operation.
Gets the component registration that is being resolved in the current request.
Gets the service that is being resolved in the current request.
Gets the target registration for decorator requests.
Gets or sets the instance that will be returned as the result of the resolve request.
On the way back up the pipeline, after calling next(ctxt), this value will be populated
with the resolved instance. Check the property to determine
whether the object here was a newly activated instance, or a shared instance previously activated.
Gets a value indicating whether the resolved is a new instance of a component has been activated during this request,
or an existing shared instance that has been retrieved.
Gets the to which trace events should be written.
Gets or sets the current resolve parameters. These can be changed using the method.
Gets or sets the phase of the pipeline reached by this request.
Gets or sets the active decorator context for the request.
Provides an event that will fire when the current request completes.
Requests will only be considered 'complete' when the overall is completing.
Use this method to change the that is used in this request. Changing this scope will
also change the available in this context.
The new lifetime scope.
Change the set of parameters being used in the processing of this request.
The new set of parameters.
Provides helpers for building service pipelines.
Gets the set of default middleware added to each service pipeline.
Gets a default pre-built service pipeline that contains only the .
Checks whether a given resolve middleware is one of the default middleware in .
The middleware to test.
True if the middleware is one of the defaults; false otherwise.
A is a component context that sequences and monitors the multiple
activations that go into producing a single requested object graph.
Initializes a new instance of the class.
The most nested scope in which to begin the operation. The operation
can move upward to less nested scopes as components with wider sharing scopes are activated.
The to which trace events should be written.
Execute the complete resolve operation.
The resolution context.
Gets the active resolve request.
Gets the current lifetime scope of the operation; based on the most recently executed request.
Gets the for the operation.
Gets the current request depth.
Gets the that initiated the operation. Other nested requests may have been
issued as a result of this one.
Enter a new dependency chain block where subsequent requests inside the operation are allowed to repeat
registrations from before the block.
A disposable that should be disposed to exit the block.
Invoke this method to execute the operation for a given request.
The resolve request.
The resolved instance.
Basic pipeline invocation steps used when retrieving an instance. Isolated
to enable it to be optionally surrounded with diagnostics.
Describes the commencement of a new resolve operation.
Initializes a new instance of the class.
The resolve operation that is beginning.
Gets the resolve operation that is beginning.
Describes the commencement of a new resolve operation.
Initializes a new instance of the class.
The resolve operation that is ending.
If included, the exception causing the operation to end; otherwise, null.
Gets the exception causing the operation to end, or null.
Gets the resolve operation that is ending.
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 An exception was thrown while executing a resolve operation. See the InnerException for details..
Looks up a localized string similar to Probable circular dependency between factory-scoped components. Chain includes '{0}'.
Looks up a localized string similar to Resolve pipeline completed with a null value for the resolved instance..
Looks up a localized string similar to This resolve operation has already ended. When registering components using lambdas, the IComponentContext 'c' parameter to the lambda cannot be stored. Instead, either resolve IComponentContext again from 'c', or resolve a Func<> based factory to create subsequent components from..
Fired when a resolve request is starting.
Initializes a new instance of the class.
The resolve request context that is starting.
Gets the resolve request that is beginning.
Fired when a resolve request is starting.
Initializes a new instance of the class.
The resolve request context that is completing.
Gets the instance lookup operation that is beginning.
Implements a segmented stack of items, which functions like a regular , but allows segments
of the stack to be enumerated without including items pushed before the segment.
The item type.
Initializes a new instance of the class.
Push an item onto the stack.
The item.
Pop the item at the top of the stack (and return it).
The item that has just been popped.
Gets the count of the items in the active segment.
Enter a new segment. When this method returns will be zero, and the stack will appear empty.
An that will return the stack to the previously active segment when disposed.
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 Cannot exit a stack segment without popping all elements of the segment..
Looks up a localized string similar to Current stack segment is empty, cannot pop..
Looks up a localized string similar to Enumerator not in valid state..
Encapsulates the call back that represents the entry point of a pipeline.
Initializes a new instance of the class.
Callback to invoke.
The for resolving the current .
Initializes a new instance of the class.
Services are the lookup keys used to locate component instances.
Gets a human-readable description of the service.
The description.
Returns a that represents the current .
A that represents the current .
Implements the operator ==.
The left operand.
The right operand.
The result of the operator.
Implements the operator !=.
The left operand.
The right operand.
The result of the operator.
Determines whether the specified is equal to the current .
The to compare with the current .
true if the specified is equal to the current ; otherwise, false.
The parameter is null.
Serves as a hash function for a particular type.
A hash code for the current .
Defines a combination of a service pipeline and a registration. Used to instantiate a .
Initializes a new instance of the struct.
A service pipeline.
The registration.
Gets the pipeline to invoke that will resolve the associated .
Gets the registration that will be resolved when a resolve request runs.
Gets additional data associated with the component.
Gets the registration order value from the registration.
The original registration order value.
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 Subclasses of Autofac.Service must override Object.Equals().
Looks up a localized string similar to Subclasses of Autofac.Service must override Object.GetHashCode().
Identifies a service according to a type to which it can be assigned.
Initializes a new instance of the class.
Type of the service.
Gets the type of the service.
The type of the service.
Gets a human-readable description of the service.
The description.
Indicates whether the current object is equal to another object of the same type.
An object to compare with this object.
true if the current object is equal to the parameter; otherwise, false.
Determines whether the specified is equal to the current .
The to compare with the current .
true if the specified is equal to the current ; otherwise, false.
The parameter is null.
Serves as a hash function for a particular type.
A hash code for the current .
Return a new service of the same kind, but carrying
as the .
The new service type.
A new service with the service type.
A handy unique service identifier type - all instances will be regarded as unequal.
Initializes a new instance of the class.
Initializes a new instance of the class.
The id.
Gets a programmer-readable description of the identifying feature of the service.
Determines whether the specified is equal to the current .
The to compare with the current .
true if the specified is equal to the current ; otherwise, false.
The parameter is null.
Serves as a hash function for a particular type.
A hash code for the current .
Provides a default resolve pipeline tracer that builds a multi-line
string describing the end-to-end operation flow. Attach to the
event to receive notifications when new trace content is available.
The tracer subscribes to all Autofac diagnostic events and can't be
unsubscribed. This is required to ensure beginning and end of each
logical activity can be captured.
Initializes a new instance of the class.
Gets the number of operations in progress being traced.
An with the number of trace IDs associated
with in-progress operations being traced by this tracer.
Provides a string builder that auto-indents lines.
Names of the events raised in diagnostics.
ID for the event raised when middleware starts.
ID for the event raised when middleware encounters an error.
ID for the event raised when middleware exits successfully.
ID for the event raised when a resolve operation encounters an error.
ID for the event raised when a resolve operation starts.
ID for the event raised when a resolve operation completes successfully.
ID for the event raised when a resolve request encounters an error.
ID for the event raised when a resolve request starts.
ID for the event raised when a resolve request completes successfully.
Extension methods for writing diagnostic messages.
Writes a diagnostic event indicating an individual middleware item is about to execute (just before the method executes).
The diagnostic source to which events will be written.
The context for the resolve request that is running.
The middleware that is about to run.
Writes a diagnostic event indicating an individual middleware item has finished in an error state (when the method returns).
The diagnostic source to which events will be written.
The context for the resolve request that is running.
The middleware that just ran.
Writes a diagnostic event indicating an individual middleware item has finished successfully (when the method returns).
The diagnostic source to which events will be written.
The context for the resolve request that is running.
The middleware that just ran.
Writes a diagnostic event indicating a resolve operation has started.
The diagnostic source to which events will be written.
The pipeline resolve operation that is about to run.
The request that is responsible for starting this operation.
Writes a diagnostic event indicating a resolve operation has failed.
The diagnostic source to which events will be written.
The resolve operation that failed.
The exception that caused the operation failure.
Writes a diagnostic event indicating a resolve operation has succeeded.
The diagnostic source to which events will be written.
The resolve operation that succeeded.
The resolved instance providing the requested service.
Writes a diagnostic event indicating a resolve request has started inside an operation.
The diagnostic source to which events will be written.
The pipeline resolve operation that this request is running within.
The context for the resolve request that is about to start.
Writes a diagnostic event indicating a resolve request inside an operation has failed.
The diagnostic source to which events will be written.
The pipeline resolve operation that this request is running within.
The context for the resolve request that failed.
The exception that caused the failure.
Writes a diagnostic event indicating a resolve request inside an operation has succeeded.
The diagnostic source to which events will be written.
The pipeline resolve operation that this request is running within.
The context for the resolve request that failed.
Base class for creating diagnostic tracers that follow Autofac diagnostic events.
Following events from a
involves subscribing to that listener with an
where the observable is a of
event names and event data.
This class helps with that by providing strongly typed event handlers
pre-wired to convert the event data into the right object type, allowing you
to focus on the handling logic and not the event/data parsing.
While technically you could subscribe to non-Autofac events using this
observer, it's not a general purpose mechanism - it's very much tailored
to Autofac.
Should you want to start emitting and subscribing to your own events in the
Autofac pipeline (e.g., a custom middleware that emits your own custom events)
you have some options:
First, you could implement your own that listens
for your custom events. Since you can subscribe any number of
to a given , having one
that derives from this class and a separate one of your own making is acceptable.
Second, you could create your own that does not
derive from this class but still listens for Autofac events as well as any
custom events you emit. Any diagnostics observer can listen for these events as
long as it's subscribed to the ;
it doesn't have to be one of this specific class type.
Finally, if you want to use this as a base but to listen for your custom events,
you can derive from this and override the
method. Handle your custom events, or if it's not one of your custom events, call
the base to handle the Autofac events.
The list of event names to which this observer is subscribed.
Subscribes the observer to a particular named diagnostic event.
The name of the event to which the observer should subscribe. Diagnostic
names are case-sensitive.
By default the observer is not subscribed to any events. You must
opt-in to any events you wish to handle. You may use
to subscribe to all Autofac events at once.
Subscribes the observer to a particular named diagnostic event.
The name of the event to which the observer should subscribe. Diagnostic
names are case-sensitive.
Derived classes may override the public method to
handle consumer calls to enabling events; constructors needing to call
non-virtual methods may directly call this to avoid executing against
partially constructed derived classes.
Subscribes the observer to all Autofac events.
By default the observer is not subscribed to any events. You must
opt-in to any events you wish to handle. This method helps you
to quickly subscribe to all the Autofac events at once. You may use
to subscribe to individual events.
Unsubscribes the observer from a particular named diagnostic event.
The name of the event to which the observer should unsubscribe. Diagnostic
names are case-sensitive.
By default the observer is not subscribed to any events. You must
opt-in to any events you wish to handle. You may use
to subscribe to all Autofac events at once,
or to subscribe to individual events.
Unsubscribes the observer from a particular named diagnostic event.
The name of the event to which the observer should unsubscribe. Diagnostic
names are case-sensitive.
Derived classes may override the public method to
handle consumer calls to disabling events; constructors needing to call
non-virtual methods may directly call this to avoid executing against
partially constructed derived classes.
Determines if this observer is enabled for listening to a specific
named event.
The name of the event to check. Diagnostic names are case-sensitive.
Notifies the observer that the provider has finished sending push-based notifications.
Notifies the observer that the provider has experienced an error condition.
An object that provides additional information about the error.
Provides the observer with new data.
The current notification information.
Handles the event raised when middleware encounters an error.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles the event raised when middleware starts.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles the event raised when middleware exits successfully.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles the event raised when a resolve operation encounters an error.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles the event raised when a resolve operation starts.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles the event raised when a resolve operation completes successfully.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles the event raised when a resolve request encounters an error.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles the event raised when a resolve request starts.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles the event raised when a resolve request completes successfully.
Diagnostic data associated with the event.
Derived classes can override this method and perform actions based
on the event. By default, the base class does nothing.
Handles inbound events and converts the diagnostic data to a
strongly-typed object that can be handled by the other methods
in this observer.
The name of the event that was raised. Diagnostic names are case-sensitive.
The diagnostic data associated with the event.
If you are interested in handling custom events, check out the top-level
documentation which discusses some
options.
Diagnostic data associated with middleware events.
Initializes a new instance of the class.
The context for the resolve request that is running.
The middleware that is running.
Gets the context for the resolve request that is running.
Gets the middleware that is running.
Base class for tracers that require all operations for logical operation tracing.
The type of content generated by the trace at the end of the operation.
Derived classes will be subscribed to all Autofac diagnostic events
and will raise an
event when a logical operation has finished and trace data is available.
Initializes a new instance of the class
and enables all subscriptions.
Initializes a new instance of the class
and enables a specified set of subscriptions.
The set of subscriptions that should be enabled by default.
Event raised when a resolve operation completes and trace data is available.
Gets the number of operations in progress being traced.
An with the number of trace IDs associated
with in-progress operations being traced by this tracer.
Invokes the event.
The arguments to provide in the raised event.
Diagnostic data associated with resolve operation failure events.
Initializes a new instance of the class.
The resolve operation that failed.
The exception that caused the operation failure.
Gets the resolve operation that failed.
Gets the exception that caused the operation failure.
Diagnostic data associated with resolve operation start events.
Initializes a new instance of the class.
The pipeline resolve operation that is about to run.
The request that is responsible for starting this operation.
Gets the pipeline resolve operation that is about to run.
Gets the request that is responsible for starting this operation.
Diagnostic data associated with resolve operation success events.
Initializes a new instance of the class.
The resolve operation that succeeded.
The resolved instance providing the requested service.
Gets the resolve operation that succeeded.
Gets the resolved instance providing the requested service.
Event data for the event.
The type of content generated by the trace at the end of the operation.
Initializes a new instance of the class.
The operation for which a trace has completed.
Indicates whether the operation succeeded.
The content of the trace.
Gets the operation for which a trace is available.
Gets a value indicating whether the operation this trace represents succeeded (if true), or failed with an exception (if false).
Gets the content of the trace.
Diagnostic data associated with resolve request events.
Initializes a new instance of the class.
The pipeline resolve operation that this request is running within.
The context for the resolve request that is running.
Gets the pipeline resolve operation that this request is running within.
Gets the context for the resolve request that is running.
Diagnostic data associated with resolve request failure events.
Initializes a new instance of the class.
The pipeline resolve operation that this request is running within.
The context for the resolve request that failed.
The exception that caused the failure.
Gets the pipeline resolve operation that this request is running within.
Gets the context for the resolve request that failed.
Gets the exception that caused the failure.
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 Component: {0}.
Looks up a localized string similar to -> {0}.
Looks up a localized string similar to {.
Looks up a localized string similar to Exception: {0}.
Looks up a localized string similar to }.
Looks up a localized string similar to X- {0}.
Looks up a localized string similar to <- {0}.
Looks up a localized string similar to Instance: {0}.
Looks up a localized string similar to Operation FAILED.
Looks up a localized string similar to Operation Succeeded; result instance was {0}.
Looks up a localized string similar to Cannot outdent; no indentation specified..
Looks up a localized string similar to Pipeline:.
Looks up a localized string similar to Resolve Operation Starting.
Looks up a localized string similar to Resolve Request FAILED.
Looks up a localized string similar to Resolve Request FAILED: Nested Resolve Failed.
Looks up a localized string similar to Resolve Request Starting.
Looks up a localized string similar to Resolve Request Succeeded; result instance was {0}.
Looks up a localized string similar to Service: {0}.
Looks up a localized string similar to You may not add or remove subscriptions on this tracer. This ensures all required events are properly captured and traces can be correctly handled..
Looks up a localized string similar to Target: {0}.
Provides an annotation to resolve constructor dependencies
according to their registered key.
This attribute allows constructor dependencies to be resolved by key.
By marking your dependencies with this attribute and associating
an attribute filter with your type registration, you can be selective
about which service registration should be used to provide the
dependency.
A simple example might be registration of a specific logger type to be
used by a class. If many loggers are registered with their own key,
the consumer can simply specify the key filter as an attribute to
the constructor parameter.
public class Manager
{
public Manager([KeyFilter("Manager")] ILogger logger)
{
// ...
}
}
The same thing can be done for enumerable:
public class SolutionExplorer
{
public SolutionExplorer(
[KeyFilter("Solution")] IEnumerable<IAdapter> adapters,
[KeyFilter("Solution")] ILogger logger)
{
Adapters = adapters.ToList();
Logger = logger;
}
}
When registering your components, the associated key on the
dependencies will be used. Be sure to specify the
extension on the type with the filtered constructor parameters.
var builder = new ContainerBuilder();
// Register the components getting filtered with keys
builder.RegisterType<ConsoleLogger>().Keyed<ILogger>("Solution");
builder.RegisterType<FileLogger>().Keyed<ILogger>("Other");
// Attach the filtering behavior to the component with the constructor
builder.RegisterType<SolutionExplorer>().WithAttributeFiltering();
var container = builder.Build();
// The resolved instance will have the appropriate services in place
var explorer = container.Resolve<SolutionExplorer>();
Initializes a new instance of the class.
The key that the dependency should have in order to satisfy the parameter.
Gets the key the dependency is expected to have to satisfy the parameter.
The corresponding to a registered service key on a component.
Resolved components must be keyed with this value to satisfy the filter.
Resolves a constructor parameter based on keyed service requirements.
The specific parameter being resolved that is marked with this attribute.
The component context under which the parameter is being resolved.
The instance of the object that should be used for the parameter value.
Thrown if or is .
Checks a constructor parameter can be resolved based on keyed service requirements.
The specific parameter being resolved that is marked with this attribute.
The component context under which the parameter is being resolved.
true if parameter can be resolved; otherwise, false.
Provides an annotation to filter constructor dependencies
according to their specified metadata.
This attribute allows constructor dependencies to be filtered by metadata.
By marking your dependencies with this attribute and associating
an attribute filter with your type registration, you can be selective
about which service registration should be used to provide the
dependency.
A simple example might be registration of a specific logger type to be
used by a class. If many loggers are registered with the LoggerName
metadata, the consumer can simply specify the filter as an attribute to
the constructor parameter.
public class Manager
{
public Manager([MetadataFilter("LoggerName", "Manager")] ILogger logger)
{
// ...
}
}
The same thing can be done for enumerable:
public class SolutionExplorer
{
public SolutionExplorer(
[MetadataFilter("Target", "Solution")] IEnumerable<IAdapter> adapters,
[MetadataFilter("LoggerName", "Solution")] ILogger logger)
{
Adapters = adapters.ToList();
Logger = logger;
}
}
When registering your components, the associated metadata on the dependencies will be used.
Be sure to specify the
extension on the type with the filtered constructor parameters.
var builder = new ContainerBuilder();
// Attach metadata to the components getting filtered
builder.RegisterType<ConsoleLogger>().WithMetadata("LoggerName", "Solution").As<ILogger>();
builder.RegisterType<FileLogger>().WithMetadata("LoggerName", "Other").As<ILogger>();
// Attach the filtering behavior to the component with the constructor
builder.RegisterType<SolutionExplorer>().WithAttributeFiltering();
var container = builder.Build();
// The resolved instance will have the appropriate services in place
var explorer = container.Resolve<SolutionExplorer>();
Initializes a new instance of the class.
The metadata key that the dependency should have in order to satisfy the parameter.
The metadata value that the dependency should have in order to satisfy the parameter.
Gets the key the dependency is expected to have to satisfy the parameter.
The corresponding to a registered metadata
key on a component. Resolved components must have this metadata key to
satisfy the filter.
Gets the value the dependency is expected to have to satisfy the parameter.
The corresponding to a registered metadata
value on a component. Resolved components must have the metadata
with
this value to satisfy the filter.
Resolves a constructor parameter based on metadata requirements.
The specific parameter being resolved that is marked with this attribute.
The component context under which the parameter is being resolved.
The instance of the object that should be used for the parameter value.
Thrown if or is .
Checks a constructor parameter can be resolved based on metadata requirements.
The specific parameter being resolved that is marked with this attribute.
The component context under which the parameter is being resolved.
true if parameter can be resolved; otherwise, false.
Base attribute class for marking constructor parameters and enabling
filtering by attributed criteria.
Implementations of this attribute can be used to mark constructor parameters
so filtering can be done based on registered service data. For example, the
allows constructor
parameters to be filtered by registered metadata criteria and the
allows constructor
parameters to be filtered by a keyed service registration.
If a type uses these attributes, it should be registered with Autofac
using the
extension to enable the behavior.
For specific attribute usage examples, see the attribute documentation.
Implemented in derived classes to resolve a specific parameter marked with this attribute.
The specific parameter being resolved that is marked with this attribute.
The component context under which the parameter is being resolved.
The instance of the object that should be used for the parameter value.
Implemented in derived classes to check a specific parameter can be resolved.
The specific parameter being resolved that is marked with this attribute.
The component context under which the parameter is being resolved.
true if parameter can be resolved; otherwise, false.
Extends registration syntax for attribute scenarios.
Applies attribute-based filtering on constructor dependencies for use with attributes
derived from the .
The type of the registration limit.
Activator data type.
Registration style type.
The registration builder containing registration data.
Registration builder allowing the registration to be configured.
Thrown if is .
Apply this extension to component registrations that use attributes
that derive from the
like the
in their constructors. Doing so will allow the attribute-based filtering to occur. See
for an
example on how to use the filter and attribute together.
Registration source providing implicit collection/list/enumerable support.
This registration source provides enumerable support to allow resolving
the set of all registered services of a given type.
What may not be immediately apparent is that it also means any time there
are no items of a particular type registered, it will always return an
empty set rather than or throwing an exception.
This is by design.
Consider the [possibly majority] use case where you're resolving a set
of message handlers or event handlers from the container. If there aren't
any handlers, you want an empty set - not or
an exception. It's valid to have no handlers registered.
This implicit support means other areas (like MVC support or manual
property injection) must take care to only request enumerable values they
expect to get something back for. In other words, "Don't ask the container
for something you don't expect to resolve".
Retrieve registrations for an unregistered service, to be used
by the container.
The service that was requested.
A function that will return existing registrations for a service.
Registrations providing the service.
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 Collection Support (Arrays and Generic Collection Interfaces).
Implements the decorator context, exposing the state of the decoration process.
Create a new .
The type of the concrete implementation.
The service type being decorated.
The instance of the implementation to be decorated.
A new decorator context.
Creates a new decorator context that consumes the specified decorator instance.
The decorated instance.
A new context.
Service middleware that decorates activated instances of a service.
Initializes a new instance of the class.
The decorator service.
The decorator registration.
A service that has been registered for the purpose of decorating other components.
This service type is used to locate decorator services and is intended for internal use only.
Gets the condition that must be met for the decorator to be applied.
Initializes a new instance of the class.
The service type for the decorator.
The condition that must be met for the decorator to be applied.
Defines the context interface used during the decoration process.
Gets the implementation type of the service that is being decorated.
Gets the service type of the service that is being decorated.
Gets the implementation types of the decorators that have been applied.
Gets the decorator instances that have been applied.
Gets the current instance in the decorator chain. This will be initialized
to the service being decorated and will then become the decorated instance
as each decorator is applied.
Service middleware source that enables open generic decorators.
Initializes a new instance of the class.
The decorator service.
The registration data for the decorator.
The activator data for the decorator.
Generates context-bound closures that represent factories from
a set of heuristics based on delegate type signatures.
Initializes a new instance of the class.
The service that will be activated in
order to create the products of the factory.
The delegate to provide as a factory.
The parameter mapping mode to use.
Initializes a new instance of the class.
The service that will be activated in
order to create the products of the factory.
The component that will be activated in
order to create the products of the factory.
The delegate to provide as a factory.
The parameter mapping mode to use.
Generates a factory delegate that closes over the provided context.
The context in which the factory will be used.
Parameters provided to the resolve call for the factory itself.
A factory delegate that will work within the context.
Generates a factory delegate that closes over the provided context.
The context in which the factory will be used.
Parameters provided to the resolve call for the factory itself.
A factory delegate that will work within the context.
Data used to create factory activators.
Initializes a new instance of the class.
The type of the factory.
The service used to provide the products of the factory.
Gets or sets a value determining how the parameters of the delegate type are passed on
to the generated Resolve() call as Parameter objects.
For Func-based delegates, this defaults to ByType. Otherwise, the
parameters will be mapped by name.
Gets the activator data that can provide an IInstanceActivator instance.
Helper methods for registering factories.
Registers a factory delegate.
Container builder.
Factory type to generate.
The service that the delegate will return instances of.
Registration builder allowing the registration to be configured.
Factory delegates are provided automatically in Autofac 2, and
this method is generally not required.
Registration source for generated factory methods (i.e. when resolving or some variant).
Retrieve registrations for an unregistered service, to be used
by the container.
The service that was requested.
A function that will return existing registrations for a service.
Registrations providing the service.
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 Unable to generate a function to return type '{0}' with input parameter types [{1}]. The input parameter type list has duplicate types. Try registering a custom delegate type instead of using a generic Func relationship..
Looks up a localized string similar to Delegate Support (Func<T>and Custom Delegates).
Determines how the parameters of the delegate type are passed on
to the generated Resolve() call as Parameter objects.
Chooses parameter mapping based on the factory type.
For Func-based factories this is equivalent to ByType, for all
others ByName will be used.
Pass the parameters supplied to the delegate through to the
underlying registration as NamedParameters based on the parameter
names in the delegate type's formal argument list.
Pass the parameters supplied to the delegate through to the
underlying registration as TypedParameters based on the parameter
types in the delegate type's formal argument list.
Pass the parameters supplied to the delegate through to the
underlying registration as PositionalParameters based on the parameter
indices in the delegate type's formal argument list.
Provides components by lookup operations via an index (key) type.
The type of the index.
The service provided by the indexed components.
Retrieving a value given a key:
IIndex<AccountType, IRenderer> accountRenderers = // ...
var renderer = accountRenderers[AccountType.User];
Get the value associated with .
The value to retrieve.
The associated value.
Get the value associated with if any is available.
The key to look up.
The retrieved value.
True if a value associated with the key exists.
Provides components by lookup operations via an index (key) type.
The index key type.
The index value type.
Initializes a new instance of the class.
The current component context.
Support the
type automatically whenever type T is registered with the container.
When a dependency of a lazy type is used, the instantiation of the underlying
component will be delayed until the Value property is first accessed.
Initializes a new instance of the class.
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 Lazy<T> Support.
Support the System.Lazy<T, TMetadata>
types automatically whenever type T is registered with the container.
Metadata values come from the component registration's metadata.
When a dependency of a lazy type is used, the instantiation of the underlying
component will be delayed until the Value property is first accessed.
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 Lazy<T, TMetadata> Support.
Describes the basic requirements for generating a lightweight adapter.
Initializes a new instance of the class.
The service that will be adapted from.
The adapter function.
Gets the adapter function.
Gets the service to be adapted from.
Extension methods for registering adapters.
Adapt all components implementing service
to provide using the provided
function.
Service type to adapt from.
Service type to adapt to. Must not be the
same as .
Container builder.
Function adapting to
service , given the context and parameters.
Decorate all components implementing service
using the provided function.
The and parameters must be different values.
Service type being decorated.
Container builder.
Function decorating a component instance that provides
, given the context and parameters.
Service key or name associated with the components being decorated.
Service key or name given to the decorated components.
A registration source for registered adapters.
Initializes a new instance of the class.
The registration data for the adapter.
The activator data for the adapter.
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 Lightweight Adapter from {0} to {1}.
Looks up a localized string similar to The service {0} cannot be both the adapter's from and to parameters - these must differ..
Helper methods for creating a metadata access function that retrieves typed metdata from a dictionary.
Generate a provider function that takes a dictionary of metadata, and outputs a typed metadata object.
The metadata type.
A provider function.
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}' cannot be used as a metadata view. A metadata view must be a concrete class with a parameterless or dictionary constructor..
Looks up a localized string similar to Export metadata for '{0}' is missing and no default value was supplied..
Support the
types automatically whenever type T is registered with the container.
Metadata values come from the component registration's metadata.
Initializes a new instance of the class.
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 Meta<T> Support.
Looks up a localized string similar to Meta<T, TMetadata> Support.
Provides a value along with metadata describing the value.
The type of the value.
An interface to which metadata values can be bound.
Initializes a new instance of the class.
The value described by the instance.
The metadata describing the value.
Gets the value described by .
Gets metadata describing the value.
Provides a value along with a dictionary of metadata describing the value.
The type of the value.
Initializes a new instance of the class.
The value described by the instance.
The metadata describing the value.
Gets the value described by .
Gets the metadata describing the value.
Support the
types automatically whenever type T is registered with the container.
Metadata values come from the component registration's metadata.
Describes the activator for an open generic decorator.
Initializes a new instance of the class.
The decorator type.
The open generic service type to decorate.
Gets the open generic service type to decorate.
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 service '{0}' is not an open generic type..
Registration source for handling open generic decorators.
Initializes a new instance of the class.
The registration data for the open generic.
The pipeline for the existing open generic registration.
The activator data.
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 service {0} cannot be both the adapter's from and to parameters - these must differ..
Looks up a localized string similar to Open Generic Decorator {0} from {1} to {2}.
Activator data for the open generic delegate activator. Holds the specified factory method.
Initializes a new instance of the class.
The factory method that will create a closed generic instance.
Gets the factory method that will create a closed generic instance.
Generates activators for open generics registered using a delegate.
Initializes a new instance of the class.
The registration data for the open generic.
The pipeline for the existing open generic registration.
The activator data.
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 Delegate providing {0}.
Extension methods to support open generic registrations.
Register an un-parameterised generic type, e.g. Repository<>.
Concrete types will be made as they are requested, e.g. with Resolve<Repository<int>>().
Container builder.
The open generic implementation type.
Registration builder allowing the registration to be configured.
Register an un-parameterised generic type, e.g. Repository<>.
Concrete types will be made as they are requested, e.g. with Resolve<Repository<int>>().
Container builder.
Delegate responsible for generating an instance of a closed generic based on the open generic type being registered.
Registration builder allowing the registration to be configured.
Creates an un-parameterised generic type, e.g. Repository<>, without registering it.
Concrete types will be made as they are requested, e.g. with Resolve<Repository<int>>().
The open generic implementation type.
Registration builder allowing the registration to be configured.
Creates a registration builder for an un-parameterised generic type, e.g. Repository<>, without registering it.
Concrete types will be made as they are requested, e.g. with Resolve<Repository<int>>().
Delegate responsible for generating an instance of a closed generic based on the open generic type being registered.
Registration builder allowing the registration to be configured.
Decorate all components implementing open generic service .
The and parameters must be different values.
Container builder.
Service type being decorated. Must be an open generic type.
Service key or name associated with the components being decorated.
Service key or name given to the decorated components.
The type of the decorator. Must be an open generic type, and accept a parameter
of type , which will be set to the instance being decorated.
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} is not an open generic type definition..
Generates activators for open generic types.
Initializes a new instance of the class.
The registration data for the open generic.
The pipeline for the existing open generic registration.
The activator data.
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 {0} providing {1}.
Helper functions for binding open generic implementations to a known implementation type.
Given a closed generic service (that is being requested), creates a closed generic implementation type
and associated services from the open generic implementation and services.
The closed generic service to bind.
The set of configured open generic services.
The implementation type of the open generic.
The built closed generic implementation type.
The built closed generic services.
True if the closed generic service can be bound. False otherwise.
Given a closed generic service (that is being requested), creates a closed generic implementation type
and associated services from the open generic implementation and services.
The closed generic service to bind.
The set of configured open generic services.
Delegate responsible for generating an instance of a closed generic based on the open generic type being registered.
The built closed generic implementation type.
The built closed generic services.
True if the closed generic service can be bound. False otherwise.
Given a closed generic service (that is being requested), creates a closed generic implementation type
and associated services from the open generic implementation and services.
The closed generic service to bind.
The set of configured open generic services.
The implementation type of the open generic.
The built closed generic implementation type.
The built closed generic services.
True if the closed generic service can be bound. False otherwise.
Given a closed generic service (that is being requested), creates a regular delegate callback
and associated services from the open generic delegate and services.
The closed generic service to bind.
The set of configured open generic services.
Delegate responsible for generating an instance of a closed generic based on the open generic type being registered.
The built closed generic implementation type.
The built closed generic services.
True if the closed generic service can be bound. False otherwise.
Throws an exception if an open generic implementation type cannot implement the set of specified open services.
The open generic implementation type.
The set of open generic services.
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}' does not implement the interface '{1}'..
Looks up a localized string similar to The implementation type '{0}' is not an open generic type definition..
Looks up a localized string similar to The service '{0}' is not an open generic type definition..
Looks up a localized string similar to The service '{1}' is not assignable from implementation type '{0}'..
Defines a key for a matching lifetime scope used by instance-per-owned.
Initializes a new instance of the class.
The encapsulated service.
Represents a dependency that can be released by the dependent component.
The service provided by the dependency.
Autofac automatically provides instances of whenever the
service is registered.
It is not necessary for , or the underlying component, to implement .
Disposing of the object is the correct way to handle cleanup of the dependency,
as this will dispose of any other components created indirectly as well.
When is resolved, a new is created for the
underlying , and tagged with the service matching ,
generally a . This means that shared instances can be tied to this
scope by registering them as InstancePerMatchingLifetimeScope(new TypedService(typeof(T))).
The component D below is disposable and implements IService:
public class D : IService, IDisposable
{
// ...
}
The dependent component C can dispose of the D instance whenever required by taking a dependency on
:
public class C
{
IService _service;
public C(Owned<IService> service)
{
_service = service;
}
void DoWork()
{
_service.Value.DoSomething();
}
void OnFinished()
{
_service.Dispose();
}
}
In general, rather than depending on directly, components will depend on
System.Func<Owned<T>> in order to create and dispose of other components as required.
Initializes a new instance of the class.
The value representing the instance.
An IDisposable interface through which ownership can be released.
Gets or sets the owned value.
Releases unmanaged and - optionally - managed resources.
true to release both managed and unmanaged resources; false to release only unmanaged resources.
Releases unmanaged and - optionally - managed resources asynchronously.
true to release both managed and unmanaged resources; false to release only unmanaged resources.
Generates registrations for services of type whenever the service
T is available.
Initializes a new instance of the class.
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 Owned<T> Support.
Provides registrations on-the-fly for any concrete type not already registered with
the container.
Initializes a new instance of the class.
Initializes a new instance of the class.
A predicate that selects types the source will register.
Retrieve registrations for an unregistered service, to be used
by the container.
The service that was requested.
A function that will return existing registrations for a service.
Registrations providing the service.
Gets a value indicating whether the registrations provided by this source are 1:1 adapters on top
of other components (e.g., Meta, Func, or Owned).
Gets or sets an expression used to configure generated registrations.
A that can be used to modify the behavior
of registrations that are generated by this source.
Returns a that represents the current .
A that represents the current .
Extension methods for configuring the .
Fluent method for setting the registration configuration on .
The registration source to configure.
A configuration action that will run on any registration provided by the source.
The with the registration configuration set.
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 "Resolve Anything" Support.
Base activation data for types located by scanning assemblies.
Initializes a new instance of the class.
Additional actions to be performed on the concrete type registration.
Gets the additional actions to be performed on the concrete type registrations.
Gets the filters applied to the types from the scanned assembly.
Gets the actions to be called once the scanning operation is complete.
Activation data for open generic types located by scanning assemblies.
Initializes a new instance of the class.
Helper methods to assist in scanning registration.
Helper methods to assist in scanning registration.
Register open generic types from the specified assemblies.
The container builder.
The set of assemblies.
A registration builder.
Specifies how an open generic type from a scanned assembly is mapped to a service.
Registration limit type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those assignable to the provided.
The limit type.
The registration style.
The registration builder.
The type or interface which all classes must be assignable from.
The registration builder.
Filters the scanned types to include only those assignable to the provided.
The limit type.
The registration style.
The registration builder.
The type or interface which all classes must be assignable from.
The service key.
The registration builder.
Filters the scanned types to include only those assignable to the provided.
The limit type.
The registration style.
The registration builder.
The type or interface which all classes must be assignable from.
A function to determine the service key for a given type.
The registration builder.
Specify how an open generic type from a scanned assembly provides metadata.
Registration limit type.
Registration style.
Registration to set metadata on.
A function mapping the type to a list of metadata items.
Registration builder allowing the registration to be configured.
Use the properties of an attribute (or interface implemented by an attribute) on the scanned type
to provide metadata values.
Inherited attributes are supported; however, there must be at most one matching attribute
in the inheritance chain.
The attribute applied to the scanned type.
Registration to set metadata on.
Registration builder allowing the registration to be configured.
Register types from the specified assemblies.
The container builder.
The set of assemblies.
A registration builder.
Register the specified types.
The container builder.
The set of types.
A registration builder.
Configures the scanning registration builder to register all closed types of the specified open generic.
The limit type.
The activator data type.
The registration style.
The registration builder.
The open generic to register closed types of.
The registration builder.
Configures the scanning registration builder to register all closed types of the specified open generic as a keyed service.
The limit type.
The activator data type.
The registration style.
The registration builder.
The open generic to register closed types of.
The service key.
The registration builder.
Configures the scanning registration builder to register all closed types of the specified open generic as a keyed service.
The limit type.
The activator data type.
The registration style.
The registration builder.
The open generic to register closed types of.
A function to determine the service key for a given type.
The registration builder.
Filters the scanned types to include only those assignable to the provided
type.
Registration limit type.
Activator data type.
Registration style.
Registration to filter types from.
The type or interface which all classes must be assignable from.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a service.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies that the components being registered should only be made the default for services
that have not already been registered.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Activation data for types located by scanning assemblies.
Initializes a new instance of the class.
Enables contravariant Resolve() for interfaces that have a single contravariant ('in') parameter.
interface IHandler<in TCommand>
{
void Handle(TCommand command);
}
class Command { }
class DerivedCommand : Command { }
class CommandHandler : IHandler<Command> { ... }
var builder = new ContainerBuilder();
builder.RegisterSource(new ContravariantRegistrationSource());
builder.RegisterType<CommandHandler>();
var container = builder.Build();
// Source enables this line, even though IHandler<Command> is the
// actual registered type.
var handler = container.Resolve<IHandler<DerivedCommand>>();
handler.Handle(new DerivedCommand());
Retrieve registrations for an unregistered service, to be used
by the container.
The service that was requested.
A function that will return existing registrations for a service.
Registrations providing the service.
If the source is queried for service s, and it returns a component that implements both s and s', then it
will not be queried again for either s or s'. This means that if the source can return other implementations
of s', it should return these, plus the transitive closure of other components implementing their
additional services, along with the implementation of s. It is not an error to return components
that do not implement .
Gets a value indicating whether the registrations provided by this source are 1:1 adapters on top
of other components (e.g., Meta, Func, or Owned).
The context in which a service can be accessed or a component's
dependencies resolved. Disposal of a context will dispose any owned
components.
Gets the associated services with the components that provide them.
Resolve an instance of the provided registration within the context.
The resolve request.
The component instance.
Creates, wires dependencies and manages lifetime for a set of components.
Most instances of are created
by a .
// See ContainerBuilder for the definition of the builder variable
using (var container = builder.Build())
{
var program = container.Resolve<Program>();
program.Run();
}
Most functionality is provided by extension methods
on the inherited interface.
Gets the to which
trace events should be written.
An tracks the instantiation of component instances.
It defines a boundary in which instances are shared and configured.
Disposing an will dispose any components that were
newly created when resolving from it, provided those components were not registered as
.
// See IContainer for definition of the container variable
using (var requestScope = container.BeginLifetimeScope())
{
// Note that handler is resolved from requestScope, not
// from the container:
var handler = requestScope.Resolve<IRequestHandler>();
handler.Handle(request);
// When requestScope is disposed, all resources used in processing
// the request will be released.
}
All long-running applications should resolve components via an
. Choosing the duration of the lifetime is application-
specific.
The standard Autofac integrations are already configured
to create and dispose s as appropriate. For example, the
integration with ASP.NET Core (via the .NET DI library) will create and dispose
one per HTTP request.
Most functionality is provided by extension methods
on the inherited interface.
Begin a new nested scope. Component instances created via the new scope
will be disposed along with it.
A new lifetime scope.
Begin a new nested scope. Component instances created via the new scope
will be disposed along with it.
The tag applied to the .
A new lifetime scope.
Begin a new nested scope, with additional components available to it.
Component instances created via the new scope
will be disposed along with it.
Any components registered in the sub-scope will only be resolvable from this new scope,
or additional child scopes subsequently resolved from it.
Components registered in the sub-scope that provide services already registered
in a parent (or root ) will
override that same service registration when resolving instances.
If you resolve an in the new scope, the returned set of components will
include both components registered in the new sub-scope, plus all registered components all the way back
up to the root .
Resolving a service from this scope that was only defined in a parent (or root )
will result in a component 'owned' by the scope it was registered in (rather than this new scope).
For example, if you registered a SingleInstance() component in the root container, but resolved it in the new sub-scope, the instance you get will
be attached to the root container, not your scope, so the same instance will be shared by all other instances.
SingleInstance() components registered in this scope will be held as long as this scope exists, but will be discarded
when the scope is disposed.
Action on a
that adds component registrations visible only in the new scope.
A new lifetime scope.
Begin a new nested scope, with additional components available to it.
Component instances created via the new scope
will be disposed along with it.
Any components registered in the sub-scope will only be resolvable from this new scope,
or additional child scopes subsequently resolved from it.
Components registered in the sub-scope that provide services already registered
in a parent (or root ) will
override that same service registration when resolving instances.
If you resolve an in the new scope, the returned set of components will
include both components registered in the new sub-scope, plus all registered components all the way back
up to the root .
Resolving a service from this scope that was only defined in a parent (or root )
will result in a component 'owned' by the scope it was registered in (rather than this new scope).
For example, if you registered a SingleInstance() component in the root container, but resolved it in the new sub-scope, the instance you get will
be attached to the root container, not your scope, so the same instance will be shared by all other instances.
SingleInstance() components registered in this scope will be held as long as this scope exists, but will be discarded
when the scope is disposed.
The tag applied to the .
Action on a
that adds component registrations visible only in the new scope.
A new lifetime scope.
Gets the disposer associated with this .
Component instances can be associated with it manually if required.
Typical usage does not require interaction with this member- it
is used when extending the container.
Gets the tag applied to the .
Tags allow a level in the lifetime hierarchy to be identified.
In most applications, tags are not necessary.
Fired when a new scope based on the current scope is beginning.
Fired when this scope is ending.
Fired when a resolve operation is beginning in this scope.
When implemented by a component, an instance of the component will be resolved
and started as soon as the container is built. Autofac will not call the Start()
method when subsequent instances are resolved. If this behavior is required, use
an OnActivated() event handler instead.
For equivalent "Stop" functionality, implement . Autofac
will always dispose a component before any of its dependencies (except in the presence
of circular dependencies, in which case the components in the cycle are disposed in
reverse-construction order.)
Components that implement and configured with a InstancePerLifetimeScope()
lifetime are still only started *once*, in the root or
where the component was registered.
Perform once-off startup processing.
Base class for user-defined modules. Modules can add a set of related components
to a container () or attach cross-cutting functionality
to other components (.
Modules are given special support in the XML configuration feature - see
https://autofac.readthedocs.io/en/latest/configuration/modules.html.
Provides a user-friendly way to implement
via .
Defining a module:
public class DataAccessModule : Module
{
public string ConnectionString { get; set; }
public override void Load(ContainerBuilder moduleBuilder)
{
moduleBuilder.RegisterGeneric(typeof(MyRepository<>))
.As(typeof(IRepository<>))
.InstancePerLifetimeScope();
moduleBuilder.Register(c => new MyDbConnection(ConnectionString))
.As<IDbConnection>()
.InstancePerMatchingLifetimeScope(WebLifetime.Request);
}
}
Using the module...
var builder = new ContainerBuilder();
builder.RegisterModule(new DataAccessModule { ConnectionString = "..." });
var container = builder.Build();
var customers = container.Resolve<IRepository<Customer>>();
Apply the module to the component registry.
Component registry to apply configuration to.
Override to add registrations to the container.
Note that the ContainerBuilder parameter is unique to this module.
The builder through which components can be
registered.
Override to attach module-specific functionality to a
component registration.
This method will be called for all existing and future component
registrations - ordering is not important.
The component registry.
The registration to attach functionality to.
Override to perform module-specific processing on a registration source.
This method will be called for all existing and future sources
- ordering is not important.
The component registry into which the source was added.
The registration source.
Gets the assembly in which the concrete module type is located. To avoid bugs whereby deriving from a module will
change the target assembly, this property can only be used by modules that inherit directly from
.
Extension methods for registering instances with a container.
Registers modules found in an assembly.
The builder to register the modules with.
The assemblies from which to register modules.
Thrown if is .
The to allow
additional chained module registrations.
Registers modules found in an assembly.
The module registrar that will make the registrations into the container.
The assemblies from which to register modules.
Thrown if is .
The to allow
additional chained module registrations.
Registers modules found in an assembly.
The builder to register the modules with.
The assemblies from which to register modules.
The type of the module to add.
Thrown if is .
The to allow
additional chained module registrations.
Registers modules found in an assembly.
The module registrar that will make the registrations into the container.
The assemblies from which to register modules.
The type of the module to add.
Thrown if is .
The to allow
additional chained module registrations.
Registers modules found in an assembly.
The builder to register the modules with.
The of the module to add.
The assemblies from which to register modules.
Thrown if or is .
The to allow
additional chained module registrations.
Registers modules found in an assembly.
The module registrar that will make the registrations into the container.
The of the module to add.
The assemblies from which to register modules.
Thrown if or is .
The to allow
additional chained module registrations.
Add a module to the container.
The builder to register the module with.
The module to add.
Thrown if is .
The to allow
additional chained module registrations.
Add a module to the container.
The module registrar that will make the registration into the container.
The module to add.
Thrown if is .
The to allow
additional chained module registrations.
Add a module to the container.
The builder to register the module with.
The module to add.
Thrown if or is .
The to allow
additional chained module registrations.
Attaches a predicate to evaluate prior to executing the registration of the module.
The predicate will run at registration time, not runtime, to determine
whether the module registration should execute.
The module registrar that will make the registrations into the container.
The predicate to run to determine if the registration should be made.
The to allow
additional chained module registrations.
Attaches a predicate such that a module registration will only be made if
a specific service type is not already registered.
The predicate will run at registration time, not runtime, to determine
whether the registration should execute.
The module registrar that will make the registrations into the container.
The service type to check for to determine if the registration should be made.
Note this is the *service type* - the As<T> part.
The to allow
additional chained module registrations.
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 Module.ThisAssembly is only available in modules that inherit directly from Module. It can't be used in '{0}' which inherits from '{1}'..
A parameter identified by name. When applied to a reflection-based
component, will be matched against
the name of the component's constructor arguments. When applied to
a delegate-based component, the parameter can be accessed using
.
Component with parameter...
public class MyComponent
{
public MyComponent(int amount) { ... }
}
Providing the parameter...
var builder = new ContainerBuilder();
builder.RegisterType<MyComponent>();
var container = builder.Build();
var myComponent = container.Resolve<MyComponent>(new NamedParameter("amount", 123));
Gets the name of the parameter.
Initializes a new instance of the class.
The name of the parameter.
The parameter value.
Extension methods that simplify extraction of parameter values from
an where T is .
Each method returns the first matching parameter value, or throws an exception if
none is provided.
At configuration time, delegate registrations can retrieve parameter values using
the methods , and :
builder.Register((c, p) => new FtpClient(p.Named<string>("server")));
These parameters can be provided at resolution time:
container.Resolve<FtpClient>(new NamedParameter("server", "ftp.example.com"));
Alternatively, the parameters can be provided via a Generated Factory - http://code.google.com/p/autofac/wiki/DelegateFactories.
Retrieve a named parameter value from a instance.
The type to which the returned value will be cast.
The available parameters to choose from.
The name of the parameter to select.
The value of the selected parameter.
Retrieve a positional parameter value from a instance.
The type to which the returned value will be cast.
The available parameters to choose from.
The zero-based position of the parameter to select.
The value of the selected parameter.
The position value is the one associated with the parameter when
it was constructed, not its index into the
sequence.
Retrieve a typed parameter value from a instance.
The type to which the returned value will be cast.
The available parameters to choose from.
The value of the selected parameter.
Extension methods for adding pipeline middleware.
Use a middleware callback in a resolve pipeline.
The container builder.
The phase of the pipeline the middleware should run at.
A callback invoked to run your middleware.
This callback takes a , containing the context for the resolve request, plus
a callback to invoke to continue the pipeline.
The same builder instance.
Use a middleware callback in a resolve pipeline.
The container builder.
The phase of the pipeline the middleware should run at.
The insertion mode specifying whether to add at the start or end of the phase.
A callback invoked to run your middleware.
This callback takes a , containing the context for the resolve request, plus
a callback to invoke to continue the pipeline.
The same builder instance.
Use a middleware callback in a resolve pipeline.
The container builder.
A description for the middleware; this will show up in any resolve tracing.
The phase of the pipeline the middleware should run at.
A callback invoked to run your middleware.
This callback takes a , containing the context for the resolve request, plus
a callback to invoke to continue the pipeline.
The same builder instance.
Use a middleware callback in a resolve pipeline.
The container builder.
A description for the middleware; this will show up in any resolve tracing.
The phase of the pipeline the middleware should run at.
The insertion mode specifying whether to add at the start or end of the phase.
A callback invoked to run your middleware.
This callback takes a , containing the context for the resolve request, plus
a callback to invoke to continue the pipeline.
The same builder instance.
A parameter that is identified according to an integer representing its
position in an argument list. When applied to a reflection-based
component, will be matched against
the indices of the component's constructor arguments. When applied to
a delegate-based component, the parameter can be accessed using
.
Component with parameter...
public class MyComponent
{
public MyComponent(int amount) { ... }
}
Providing the parameter...
var builder = new ContainerBuilder();
builder.RegisterType<MyComponent>();
var container = builder.Build();
var myComponent = container.Resolve<MyComponent>(new PositionalParameter(0, 123));
Gets the zero-based position of the parameter.
Initializes a new instance of the class.
The zero-based position of the parameter.
The parameter value.
Options that can be applied when autowiring properties on a component. (Multiple options can
be specified using bitwise 'or' - e.g. AllowCircularDependencies | PreserveSetValues.
Default behavior. Circular dependencies are not allowed; existing non-default
property values are overwritten.
Allows property-property and property-constructor circular dependency wiring.
This flag moves property wiring from the Activating to the Activated event.
If specified, properties that already have a non-default value will be left
unchanged in the wiring operation.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adds registration syntax to the type.
Adapt all components implementing service
to provide using the provided
function.
Service type to adapt from.
Service type to adapt to. Must not be the
same as .
Container builder.
Function adapting to
service , given the context and parameters.
Adapt all components implementing service
to provide using the provided
function.
Service type to adapt from.
Service type to adapt to. Must not be the
same as .
Container builder.
Function adapting to
service , given the context.
Adapt all components implementing service
to provide using the provided
function.
Service type to adapt from.
Service type to adapt to. Must not be the
same as .
Container builder.
Function adapting to
service .
Register all types in an assembly.
Container builder.
The assemblies from which to register types.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a service.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a service.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a service.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a service.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies that a type from a scanned assembly provides its own concrete type as a service.
Registration limit type.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Specifies that a type provides its own concrete type as a service.
Registration limit type.
Activator data type.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Specifies that a type provides its own concrete type as a service.
Registration limit type.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Specifies that a type from a scanned assembly is registered as providing all of its
implemented interfaces.
Registration limit type.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Specifies that a type is registered as providing all of its implemented interfaces.
Registration limit type.
Activator data type.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Specifies that a type is registered as providing all of its implemented interfaces.
Registration limit type.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Specifies that the components being registered should only be made the default for services
that have not already been registered.
Registration limit type.
Registration style.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Register the types in a list.
Container builder.
The types to register.
Registration builder allowing the registration to be configured.
Specifies that a type from a scanned assembly is registered if it implements an interface
that closes the provided open generic interface type.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
The open generic interface or base class type for which implementations will be found.
Registration builder allowing the registration to be configured.
Specifies that a type from a scanned assembly is registered if it implements an interface
that closes the provided open generic interface type.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
The open generic interface or base class type for which implementations will be found.
Key of the service.
Registration builder allowing the registration to be configured.
Specifies that a type from a scanned assembly is registered if it implements an interface
that closes the provided open generic interface type.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
The open generic interface or base class type for which implementations will be found.
Function mapping types to service keys.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those assignable to the provided
type.
Registration limit type.
Activator data type.
Registration style.
Registration to filter types from.
The type or interface which all classes must be assignable from.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those assignable to the provided
type.
Registration to filter types from.
The type or interface which all classes must be assignable from.
Registration builder allowing the registration to be configured.
Filters the scanned types to exclude the provided type.
Registration to filter types from.
The concrete type to exclude.
Registration builder allowing the registration to be configured.
Filters the scanned types to exclude the provided type, providing specific configuration for
the excluded type.
Registration to filter types from.
Registration for the excepted type.
The concrete type to exclude.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those in the namespace of the provided type
or one of its sub-namespaces.
Registration to filter types from.
A type in the target namespace.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those in the provided namespace
or one of its sub-namespaces.
Registration limit type.
Activator data type.
Registration style.
Registration to filter types from.
The namespace from which types will be selected.
Registration builder allowing the registration to be configured.
Specifies a subset of types to register from a scanned assembly.
Registration limit type.
Activator data type.
Registration style.
Registration to filter types from.
Predicate that returns true for types to register.
Registration builder allowing the registration to be configured.
Register a composite type that should always provide the instance of when it is resolved,
regardless of what other registrations for are available.
Composite registrations are not included when resolving a collection of .
Service type of the composite. Must accept a parameter
of type , or ,
which will be set to collection of registered implementations.
Service type to provide a composite for.
Container builder.
Register a composite type that should always provide the instance of when it is resolved,
regardless of what other registrations for are available.
Composite registrations are not included when resolving a collection of .
Container builder.
Service type of the composite. Must accept a parameter
of type , or an array of ,
which will be set to the collection of registered implementations.
Service type to provide a composite for.
Register a delegate that should always provide the composite instance of a service type when it is resolved,
regardless of what other registrations for are available.
Composite registrations are not included when resolving a collection of .
Container builder.
Callback to create a new instance of the composite, which takes the set of concrete implementations.
Service type to provide a composite for.
Register a delegate that should always provide the composite instance of a service type when it is resolved,
regardless of what other registrations for are available.
Composite registrations are not included when resolving a collection of .
Container builder.
Callback to create a new instance of the composite, which takes the set of concrete implementations.
Service type to provide a composite for.
Register an un-parameterised generic type, e.g. Composite<> to function as a composite
for an open generic service, e.g. IRepository<>. Composites will be made as they are requested,
e.g. with Resolve<IRepository<int>>().
Composite registrations are not included when resolving a collection of .
Container builder.
Service type of the composite. Must accept a parameter
of type , or an array of ,
which will be set to the collection of registered implementations.
Service type to provide a composite for.
Attaches a predicate to evaluate prior to executing the registration.
The predicate will run at registration time, not runtime, to determine
whether the registration should execute.
Registration limit type.
Activator data type.
Registration style.
The registration to configure.
The predicate to run to determine if the registration should be made.
A registration builder allowing further configuration of the component.
Thrown if or is .
Thrown if has no reference to the original callback
with which it was associated (e.g., it wasn't made with a standard registration method
as part of a ).
Attaches a predicate such that a registration will only be made if
a specific service type is not already registered.
The predicate will run at registration time, not runtime, to determine
whether the registration should execute.
Registration limit type.
Activator data type.
Registration style.
The registration to configure.
The service type to check for to determine if the registration should be made.
Note this is the *service type* - the As<T> part.
A registration builder allowing further configuration of the component.
Thrown if or is .
Thrown if has no reference to the original callback
with which it was associated (e.g., it wasn't made with a standard registration method
as part of a ).
Add a component to the container.
The builder to register the component with.
The component to add.
Register an instance as a component.
The type of the instance.
Container builder.
The instance to register.
Registration builder allowing the registration to be configured.
If no services are explicitly specified for the instance, the
static type will be used as the default service (i.e. *not* instance.GetType()).
Register a component to be created through reflection.
The type of the component implementation.
Container builder.
Registration builder allowing the registration to be configured.
Register a component to be created through reflection.
The type of the component implementation.
Container builder.
Registration builder allowing the registration to be configured.
Register a delegate as a component.
The type of the instance.
Container builder.
The delegate to register.
Registration builder allowing the registration to be configured.
Register a delegate as a component.
The type of the instance.
Container builder.
The delegate to register.
Registration builder allowing the registration to be configured.
Specifies that the component being registered should only be made the default for services
that have not already been registered.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Specify how a type from a scanned assembly provides metadata.
Registration limit type.
Activator data type.
Registration style.
Registration to set metadata on.
A function mapping the type to a list of metadata items.
Registration builder allowing the registration to be configured.
Use the properties of an attribute (or interface implemented by an attribute) on the scanned type
to provide metadata values.
Inherited attributes are supported; however, there must be at most one matching attribute
in the inheritance chain.
The attribute applied to the scanned type.
Registration to set metadata on.
Registration builder allowing the registration to be configured.
Specify how a type from a scanned assembly provides metadata.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Key of the metadata item.
A function retrieving the value of the item from the component type.
Registration builder allowing the registration to be configured.
Set the policy used to find candidate constructors on the implementation type.
Registration limit type.
Activator data type.
Registration style.
Registration to set policy on.
Policy to be used when searching for constructors.
A registration builder allowing further configuration of the component.
Set the policy used to find candidate constructors on the implementation type.
Registration limit type.
Activator data type.
Registration style.
Registration to set policy on.
A function that returns the constructors to select from.
A registration builder allowing further configuration of the component.
Configure the component so that any properties whose types are registered in the
container will be wired to instances of the appropriate service.
Registration to auto-wire properties.
Set wiring options such as circular dependency wiring support.
A registration builder allowing further configuration of the component.
Set the policy used to find candidate properties on the implementation type.
Registration limit type.
Activator data type.
Registration style.
Registration to set policy on.
Policy to be used when searching for properties to inject.
A registration builder allowing further configuration of the component.
Set the policy used to select from available constructors on the implementation type.
Registration limit type.
Activator data type.
Registration style.
Registration to set policy on.
Constructor signature to match.
A registration builder allowing further configuration of the component.
Set the policy used to select from available constructors on the implementation type.
Registration limit type.
Activator data type.
Registration style.
Registration to set policy on.
Policy to be used when selecting a constructor.
A registration builder allowing further configuration of the component.
Set the policy used to select from available constructors on the implementation type.
Registration limit type.
Activator data type.
Registration style.
Registration to set policy on.
Expression demonstrating how the constructor is called.
A registration builder allowing further configuration of the component.
Configure an explicit value for a constructor parameter.
Registration limit type.
Activator data type.
Registration style.
Registration to set parameter on.
Name of a constructor parameter on the target type.
Value to supply to the parameter.0
A registration builder allowing further configuration of the component.
Configure an explicit value for a constructor parameter.
Registration limit type.
Activator data type.
Registration style.
Registration to set parameter on.
The parameter to supply to the constructor.
A registration builder allowing further configuration of the component.
Configure an explicit value for a constructor parameter.
Registration limit type.
Activator data type.
Registration style.
Registration to set parameter on.
A predicate selecting the parameter to set.
The provider that will generate the parameter value.
A registration builder allowing further configuration of the component.
Configure explicit values for constructor parameters.
Registration limit type.
Activator data type.
Registration style.
Registration to set parameter on.
The parameters to supply to the constructor.
A registration builder allowing further configuration of the component.
Configure an explicit value for a property.
Registration limit type.
Activator data type.
Registration style.
Registration to set property on.
Name of a property on the target type.
Value to supply to the property.
A registration builder allowing further configuration of the component.
Configure an explicit value for a property.
Registration limit type.
Activator data type.
Registration style.
Registration to set parameter on.
The property to supply.
A registration builder allowing further configuration of the component.
Configure an explicit value for a property.
Registration limit type.
Activator data type.
Registration style.
Type of the property being assigned.
Registration to set property on.
Expression of a property on the target type.
Value to supply to the property.
A registration builder allowing further configuration of the component.
Configure explicit values for properties.
Registration limit type.
Activator data type.
Registration style.
Registration to set parameter on.
The properties to supply.
A registration builder allowing further configuration of the component.
Sets the target of the registration (used for metadata generation).
The type of the limit.
The type of the activator data.
Registration style.
Registration to set target for.
The target.
Registration builder allowing the registration to be configured.
Thrown if or is .
Wraps a registration in an implicit and automatically
activates the registration after the container is built.
Registration to set release action for.
Registration limit type.
Activator data type.
Registration style.
A registration builder allowing further configuration of the component.
While you can implement an to perform some logic at
container build time, sometimes you need to just activate a registered component and
that's it. This extension allows you to automatically activate a registration on
container build. No additional logic is executed and the resolved instance is not held
so container disposal will end up disposing of the instance.
Depending on how you register the lifetime of the component, you may get an exception
when you build the container - components that are scoped to specific lifetimes (like
ASP.NET components scoped to a request lifetime) will fail to resolve because the
appropriate lifetime is not available.
Share one instance of the component within the context of a single
web/HTTP/API request. Only available for integration that supports
per-request dependencies (e.g., MVC, Web API, web forms, etc.).
Registration limit type.
Activator data type.
Registration style.
The registration to configure.
Additional tags applied for matching lifetime scopes.
A registration builder allowing further configuration of the component.
Thrown if is .
Decorate all components implementing open generic service .
The and parameters must be different values.
Container builder.
Service type being decorated. Must be an open generic type.
Service key or name associated with the components being decorated.
Service key or name given to the decorated components.
The type of the decorator. Must be an open generic type, and accept a parameter
of type , which will be set to the instance being decorated.
Decorate all components implementing service
using the provided function.
The and parameters must be different values.
Service type being decorated.
Container builder.
Function decorating a component instance that provides
, given the context and parameters.
Service key or name associated with the components being decorated.
Service key or name given to the decorated components.
Decorate all components implementing service
using the provided function.
The and parameters must be different values.
Service type being decorated.
Container builder.
Function decorating a component instance that provides
, given the context.
Service key or name associated with the components being decorated.
Service key or name given to the decorated components.
Decorate all components implementing service
using the provided function.
The and parameters must be different values.
Service type being decorated.
Container builder.
Function decorating a component instance that provides
.
Service key or name associated with the components being decorated.
Service key or name given to the decorated components.
Decorate all components implementing service
with decorator service .
Service type of the decorator. Must accept a parameter
of type , which will be set to the instance being decorated.
Service type being decorated.
Container builder.
A function that when provided with an
instance determines if the decorator should be applied.
Decorate all components implementing service
with decorator service .
Container builder.
Service type of the decorator. Must accept a parameter
of type , which will be set to the instance being decorated.
Service type being decorated.
A function that when provided with an
instance determines if the decorator should be applied.
Decorate all components implementing service
using the provided function.
Service type being decorated.
Container builder.
Function decorating a component instance that provides
, given the context, parameters and service to decorate.
A function that when provided with an
instance determines if the decorator should be applied.
Decorate all components implementing open generic service .
Container builder.
The type of the decorator. Must be an open generic type, and accept a parameter
of type , which will be set to the instance being decorated.
Service type being decorated. Must be an open generic type.
A function that when provided with an
instance determines if the decorator should be applied.
Provide a handler to be called when the component is registered.
Registration limit type.
Activator data type.
Registration style.
Registration add handler to.
The handler.
Registration builder allowing the registration to be configured.
Provide a handler to be called when the component is registred.
Registration limit type.
Registration style.
Registration add handler to.
The handler.
Registration builder allowing the registration to be configured.
Run a supplied action instead of disposing instances when they're no
longer required.
Registration limit type.
Activator data type.
Registration style.
Registration to set release action for.
An action to perform instead of disposing the instance.
Registration builder allowing the registration to be configured.
Run a supplied async action instead of disposing instances when they're no
longer required.
Registration limit type.
Activator data type.
Registration style.
Registration to set release action for.
An action to perform instead of disposing the instance.
The release/disposal process will not continue until the returned task completes.
Registration builder allowing the registration to be configured.
Register an un-parameterised generic type, e.g. Repository<>.
Concrete types will be made as they are requested, e.g. with Resolve<Repository<int>>().
Container builder.
The open generic implementation type.
Registration builder allowing the registration to be configured.
Register a delegate that can provide instances of an open generic registration.
The container builder.
Delegate responsible for generating an instance of a closed generic based on the open generic type being registered. It will be called with the current and the array of generic type arguments expected to be in the closed generic.
Registration builder allowing the registration to be configured.
Register a delegate that can provide instances of an open generic registration.
The container builder.
Delegate responsible for generating an instance of a closed generic based on the open generic type being registered. It will be called with the current , the array of generic type arguments expected to be in the closed generic, and any parameters passed to the resolve operation.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a keyed service.
Registration to set service mapping on.
Service type provided by the component.
Function mapping types to service keys.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a keyed service.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Service type provided by the component.
Function mapping types to service keys.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a named service.
Registration to set service mapping on.
Service type provided by the component.
Function mapping types to service names.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to a named service.
Registration limit type.
Activator data type.
Registration style.
Registration to set service mapping on.
Service type provided by the component.
Function mapping types to service names.
Registration builder allowing the registration to be configured.
Register all open generic types in an assembly.
Container builder.
The assemblies from which to register open generic types.
Registration builder allowing the registration to be configured.
Specifies how an open generic type from a scanned assembly is mapped to services.
Registration limit type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies how an open generic type from a scanned assembly is mapped to a service.
Registration limit type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies how an open generic type from a scanned assembly is mapped to a type.
Registration limit type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies how a type from a scanned assembly is mapped to types.
Registration limit type.
Registration style.
Registration to set service mapping on.
Function mapping types to services.
Registration builder allowing the registration to be configured.
Specifies that an open generic type from a scanned assembly provides its own open generic type as a service.
Registration limit type.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
Filters the scanned open generic types to exclude the provided type.
Registration to filter types from.
The open generic type to exclude.
Registration builder allowing the registration to be configured.
Filters the scanned open generic types to exclude the provided type, providing specific configuration for
the excluded type.
Registration to filter types from.
The concrete type to exclude.
Registration for the excepted type.
Registration builder allowing the registration to be configured.
Specifies a subset of open generic types to register from a scanned assembly.
Registration limit type.
Registration style.
Registration to filter types from.
Predicate that returns true for types to register.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those assignable to the provided.
Registration limit type.
Registration style.
Registration to set service mapping on.
The type or interface which all classes must be assignable from.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those assignable to the provided.
Registration limit type.
Registration style.
Registration to set service mapping on.
The type or interface which all classes must be assignable from.
Key of the service.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those assignable to the provided.
Registration limit type.
Registration style.
Registration to set service mapping on.
The type or interface which all classes must be assignable from.
Function mapping types to service keys.
Registration builder allowing the registration to be configured.
Filters the scanned open generic types to include only those in the namespace of the provided type
or one of its sub-namespaces.
Registration to filter types from.
A type in the target namespace.
Registration builder allowing the registration to be configured.
Filters the scanned types to include only those in the provided namespace
or one of its sub-namespaces.
Registration limit type.
Registration style.
Registration to filter types from.
The namespace from which types will be selected.
Registration builder allowing the registration to be configured.
Specifies that an open generic type from a scanned assembly is registered as providing all of its
implemented interfaces.
Registration limit type.
Registration to set service mapping on.
Registration builder allowing the registration to be configured.
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 A composite registration ({0}) is registered against multiple services. Composites can only be registered as providing a single service..
Looks up a localized string similar to A decorator for '{0}' was not provided with an instance parameter..
Looks up a localized string similar to Expression does not refer to a property..
Looks up a localized string similar to The instance registration '{0}' can support SingleInstance() sharing only..
Looks up a localized string similar to A metadata attribute of type '{0}' was not found on '{1}'..
Looks up a localized string similar to More than one metadata attribute of type '{0}' was found on '{1}'..
Looks up a localized string similar to No matching constructor exists on type '{0}'..
Looks up a localized string similar to You can only attach a registration predicate to a registration that has a callback container attached (e.g., one that was made with a standard ContainerBuilder extension method)..
Adds syntactic convenience methods to the interface.
The name, provided when properties are injected onto an existing instance.
Set any properties on that can be
resolved in the context.
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
.
Set any properties on that can be
resolved in the context.
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
Optional parameters to use during the property injection.
.
Set any properties on that can be
resolved in the context.
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
Optional parameters to use during the property injection.
.
Set any properties on that can be resolved by service and that satisfy the
constraints imposed by .
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
Selector to determine with properties should be injected.
.
Set any properties on that can be resolved by service and that satisfy the
constraints imposed by .
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
Selector to determine with properties should be injected.
Optional parameters to use during the property injection.
.
Set any properties on that can be resolved by service and that satisfy the
constraints imposed by .
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
Selector to determine with properties should be injected.
Optional parameters to use during the property injection.
.
Set any null-valued properties on that can be
resolved by the container.
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
.
Set any null-valued properties on that can be
resolved by the container.
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
Optional parameters to use during the property injection.
.
Set any null-valued properties on that can be
resolved by the container.
Type of instance. Used only to provide method chaining.
The context from which to resolve the service.
The instance to inject properties into.
Optional parameters to use during the property injection.
.
Determine whether the specified service is available in the context.
The context from which to resolve the service.
The service to test for the registration of.
True if the service is registered.
Determine whether the specified service is available in the context.
The context from which to resolve the service.
The service to test for the registration of.
True if the service is registered.
Determine whether the specified service is available in the context.
The context from which to resolve the service.
The service to test for the registration of.
True if the service is registered.
Determine whether the specified service is available in the context.
The context from which to resolve the service.
The key of the service to test for the registration of.
Type type of the service to test for the registration of.
True if the service is registered.
Determine whether the specified service is available in the context.
The context from which to resolve the service.
The key of the service to test for the registration of.
Type type of the service to test for the registration of.
True if the service is registered.
Determine whether the specified service is available in the context.
The context from which to resolve the service.
The name of the service to test for the registration of.
Type type of the service to test for the registration of.
True if the service is registered.
Determine whether the specified service is available in the context.
The context from which to resolve the service.
The name of the service to test for the registration of.
Type type of the service to test for the registration of.
True if the service is registered.
Retrieve a service from the context.
The service to retrieve.
The context from which to resolve the service.
The component instance that provides the service.
Retrieve a service from the context.
The type to which the result will be cast.
The context from which to resolve the service.
Parameters for the service.
The component instance that provides the service.
Retrieve a service from the context.
The type to which the result will be cast.
The context from which to resolve the service.
Parameters for the service.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
The service type.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Parameters for the service.
The service type.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Parameters for the service.
The service type.
The component instance that provides the service.
Retrieve a service from the context.
The type to which the result will be cast.
The context from which to resolve the service.
Key of the service.
The component instance that provides the service.
Retrieve a service from the context.
The type to which the result will be cast.
The context from which to resolve the service.
Key of the service.
The parameters.
The component instance that provides the service.
Retrieve a service from the context.
The type to which the result will be cast.
The context from which to resolve the service.
Key of the service.
The parameters.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Key of the service.
Type of the service.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Key of the service.
Type of the service.
The parameters.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Key of the service.
Type of the service.
The parameters.
The component instance that provides the service.
Retrieve a service from the context.
The type to which the result will be cast.
The context from which to resolve the service.
Name of the service.
The component instance that provides the service.
Retrieve a service from the context.
The type to which the result will be cast.
The context from which to resolve the service.
Name of the service.
The parameters.
The component instance that provides the service.
Retrieve a service from the context.
The type to which the result will be cast.
The context from which to resolve the service.
Name of the service.
The parameters.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
The service name.
Type of the service.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Parameters for the service.
The service name.
Type of the service.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Parameters for the service.
The service name.
Type of the service.
The component instance that provides the service.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The type of the service.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The type of the service.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The type of the service.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The key of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The service.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The service.
Parameters for the service.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The service.
Parameters for the service.
The component instance that provides the service, or null.
Retrieve a service from the context.
The context from which to resolve the service.
The service to resolve.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Parameters for the service.
The service to resolve.
The component instance that provides the service.
Retrieve a service from the context.
The context from which to resolve the service.
Parameters for the service.
The service to resolve.
The component instance that provides the service.
Try to retrieve a service from the context.
The service type to resolve.
The context from which to resolve the service.
The resulting component instance providing the service, or default(T).
True if a component providing the service is available.
Try to retrieve a service from the context.
The context from which to resolve the service.
The service type to resolve.
The resulting component instance providing the service, or null.
True if a component providing the service is available.
Try to retrieve a service from the context.
The service type to resolve.
The context from which to resolve the service.
The key of the service to resolve.
The resulting component instance providing the service, or null.
True if a component providing the service is available.
Try to retrieve a service from the context.
The context from which to resolve the service.
The key of the service to resolve.
The type of the service to resolve.
The resulting component instance providing the service, or null.
True if a component providing the service is available.
Try to retrieve a service from the context.
The service type to resolve.
The context from which to resolve the service.
The name of the service to resolve.
The resulting component instance providing the service, or null.
True if a component providing the service is available.
Try to retrieve a service from the context.
The context from which to resolve the service.
The name of the service to resolve.
The type of the service to resolve.
The resulting component instance providing the service, or null.
True if a component providing the service is available.
Try to retrieve a service from the context.
The context from which to resolve the service.
The service to resolve.
The resulting component instance providing the service, or null.
True if a component providing the service is available.
Try to retrieve a service from the context.
The context from which to resolve the service.
The service to resolve.
The resulting component instance providing the service, or null.
The parameters.
True if a component providing the service is available.
Thrown if is .
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 Resolved instance of type '{0}' could not be cast to the requested service type '{1}'..
Adds syntactic convenience methods to the interface,
specifically to support value types in the nullable reference scenario.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The key of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Retrieve a service from the context, or null if the service is not
registered.
The context from which to resolve the service.
Parameters for the service.
The name of the service.
The service to resolve.
The component instance that provides the service, or null.
Try to retrieve a service from the context.
The service type to resolve.
The context from which to resolve the service.
The resulting component instance providing the service, or default(T).
True if a component providing the service is available.
The details of an individual request to resolve a service.
Initializes a new instance of the class.
The service being resolved.
The component registration for the service.
The parameters used when resolving the service.
The target component to be decorated.
Gets the service being resolved.
Gets the component registration for the service being resolved. This may be null if a service is being supplied without registrations.
Gets the resolve pipeline for the request.
Gets the parameters used when resolving the service.
Gets the component registration for the decorator target if configured.
Convenience filters for use with assembly scanning registrations.
Filters scanned assembly types to be only the public types.
Registration limit type.
Activator data type.
Registration style.
Registration to filter types from.
Registration builder allowing the registration to be configured.
Extension methods for registering service middleware.
Register a resolve middleware for a particular service.
The container builder.
The service to register middleware for.
The middleware to register.
The insertion mode of the middleware (start or end of phase).
Register a resolve middleware for services providing a particular type.
The service type.
The container builder.
The middleware to register.
The insertion mode of the middleware (start or end of phase).
Register a resolve middleware for services providing a particular type.
The service type.
The container builder.
The phase of the pipeline the middleware should run at.
A callback invoked to run your middleware.
This callback takes a , containing the context for the resolve request, plus
a callback to invoke to continue the pipeline.
Register a resolve middleware for services providing a particular type.
The service type.
The container builder.
A description for the middleware; this will show up in any resolve tracing.
The phase of the pipeline the middleware should run at.
A callback invoked to run your middleware.
This callback takes a , containing the context for the resolve request, plus
a callback to invoke to continue the pipeline.
Register a resolve middleware for services providing a particular type.
The service type.
The container builder.
A description for the middleware; this will show up in any resolve tracing.
The phase of the pipeline the middleware should run at.
A callback invoked to run your middleware.
This callback takes a , containing the context for the resolve request, plus
a callback to invoke to continue the pipeline.
The insertion mode of the middleware (start or end of phase).
Register a resolve middleware for services providing a particular type.
The container builder.
The service type.
The middleware to register.
The insertion mode of the middleware (start or end of phase).
Register a source of service middleware.
The container builder.
The source to add.
A registrar to assist with fluent addition of sources.
Extension methods for registering instances with a container.
Add a registration source to the container.
The builder to register the registration source via.
The registration source to add.
The to allow additional chained registration source registrations.
Add a registration source to the container.
The builder to register the registration source with.
The registration source to add.
Thrown if is .
The to allow additional chained registration source registrations.
Add a registration source to the container.
The source registrar that will make the registration into the container.
The registration source to add.
Thrown if is .
The to allow additional chained registration source registrations.
A parameter that can supply values to sites that exactly
match a specified type. When applied to a reflection-based
component, will be matched against
the types of the component's constructor arguments. When applied to
a delegate-based component, the parameter can be accessed using
.
Component with parameter...
public class MyComponent
{
public MyComponent(int amount) { ... }
}
Providing the parameter...
var builder = new ContainerBuilder();
builder.RegisterType<MyComponent>();
var container = builder.Build();
var myComponent = container.Resolve<MyComponent>(new TypedParameter(typeof(int), 123));
Gets the type against which targets are matched.
Initializes a new instance of the class.
The exact type to match.
The parameter value.
Shortcut for creating
by using the .
Type to be used for the parameter.
The parameter value.
New typed parameter.
Extends with methods that are useful in
building scanning rules for .
Returns true if this type is in the namespace
or one of its sub-namespaces.
The type to test.
The namespace to test.
True if this type is in the namespace
or one of its sub-namespaces; otherwise, false.
Returns true if this type is in the same namespace as
or one of its sub-namespaces.
The type to test.
True if this type is in the same namespace as
or one of its sub-namespaces; otherwise, false.
Determines whether the candidate type supports any base or
interface that closes the provided generic type.
The type to test.
The open generic against which the type should be tested.
Determines whether this type is assignable to .
The type to test assignability to.
The type to test.
True if this type is assignable to references of type
; otherwise, False.
Returns an object that represents the specified method declared by the
current type.
The type.
The name of the method.
An object that represents the specified method, if found; otherwise, null.
Returns an object that represents the specified property declared by the
current type.
The type.
The name of the property.
An object that represents the specified property, if found; otherwise, null.
Returns a collection of instance constructor information that represents the declared constructors
for the type (public and private).
The type.
A collection of instance constructors.
Returns a collection of instance constructor information that represents the declared constructors
for the type (public only).
The type.
A collection of instance constructors.
Finds an instance constructor with the matching type parameters.
The type being tested.
The types of the contractor to find.
The is a match is found; otherwise, null.
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 Requested type member cannot be found..
Looks up a localized string similar to The type '{0}' is not an open generic class or interface type so it won't work with methods that act on open generics..
Extension methods for .
Safely returns the set of loadable types from an assembly.
The from which to load types.
The set of types from the , or the subset
of types that could be loaded if there was any error.
Thrown if is .
Adapts an async action to the interface.
Initializes a new instance of the class.
The async action to execute on disposal.
A factory that retrieves the value on which the
should be executed.
Base class for disposable objects.
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Releases unmanaged and - optionally - managed resources.
true to release both managed and unmanaged resources; false to release only unmanaged resources.
Gets a value indicating whether the current instance has been disposed.
Releases unmanaged and - optionally - managed resources, asynchronously.
true to release both managed and unmanaged resources; false to release only unmanaged resources.
Helper methods used throughout the codebase.
Enforce that sequence does not contain null. Returns the
value if valid so that it can be used inline in
base initialiser syntax.
The value.
The parameter name.
Enforces that the provided object is non-null.
The type of value being checked.
The value.
if not null.
Enforce that an argument is not null or empty. Returns the
value if valid so that it can be used inline in
base initialiser syntax.
The value.
The description.
if not null or empty.
Enforce that the argument is a delegate type.
The type to test.
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 argument '{0}' cannot be empty..
Looks up a localized string similar to The object of type '{0}' cannot be null..
Looks up a localized string similar to Type {0} returns void..
Looks up a localized string similar to The sequence provided as argument '{0}' cannot contain null elements..
Looks up a localized string similar to Type {0} is not a delegate type..
Dictionary used to allow local property get/set and fall back to parent values.
Storage for local values set in the dictionary.
The parent dictionary to which values should fall back when not present in the current dictionary.
Initializes a new instance of the class
with an empty parent.
Initializes a new instance of the class
with a specified parent.
The parent dictionary to which values should fall back when not present in the current dictionary.
Gets the number of elements contained in the dictionary.
The number of elements contained in this collection plus the parent collection, minus overlapping key counts.
Gets a value indicating whether this collection is read-only.
Always returns .
Gets an containing the keys of the dictionary.
An containing the keys of the dictionary without duplicates.
The order of the keys in the returned is unspecified,
but it is guaranteed to be the same order as the corresponding values in the
returned by the property.
Gets an containing the values of the dictionary.
An containing the values of the dictionary with overrides taken into account.
The order of the keys in the returned is unspecified,
but it is guaranteed to be the same order as the corresponding keys in the
returned by the property.
Gets or sets the with the specified key.
The .
The key.
Changes made to this dictionary do not affect the parent.
Adds an item to the dictionary.
The object to add to the dictionary.
Changes made to this dictionary do not affect the parent.
Adds an element with the provided key and value to the dictionary.
The object to use as the key of the element to add.
The object to use as the value of the element to add.
Changes made to this dictionary do not affect the parent.
Thrown if is .
Thrown if an element with the same key is already present in the local or parent dictionary.
Removes all items from the dictionary. Does not clear parent entries, only local overrides.
Determines whether the dictionary contains a specific value.
The object to locate in the dictionary.
if is found in the dictionary; otherwise, .
Determines whether the dictionary contains an element with the specified key.
The key to locate in the dictionary.
if the dictionary or its parent contains an element with the key; otherwise, .
Copies the elements of the dictionary to an , starting at a particular index.
The one-dimensional that is the destination of the elements copied from
the dictionary. The must have zero-based indexing.
The zero-based index in at which copying begins.
Returns an enumerator that iterates through the collection.
An enumerator that can be used to iterate through the collection.
Removes the first occurrence of a specific object from the dictionary.
The object to remove from the dictionary.
if was successfully removed from the dictionary; otherwise, .
This method also returns if is not found in the original dictionary.
Changes made to this dictionary do not affect the parent.
Removes the element with the specified key from the dictionary.
The key of the element to remove.
if the element is successfully removed; otherwise, .
This method also returns if was not found in the original dictionary.
Changes made to this dictionary do not affect the parent.
Gets the value associated with the specified key.
The key whose value to get.
When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the parameter. This parameter is passed uninitialized.
if the dictionary or parent contains an element with the specified key; otherwise, .
Returns an enumerator that iterates through a collection.
An object that can be used to iterate through the collection.
Gets the list of correctly ordered unique keys from the local and parent dictionaries.
An with the unique set of all keys.
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 Item has already been added with key '{0}'..
Extension methods for reflection-related types.
Create a typed delegate from a method info and the target object.
The delegate.
The method.
The target object for the delegate.
A constructed delegate.
Maps from a property-set-value parameter to the declaring property.
Parameter to the property setter.
The property info on which the setter is specified.
True if the parameter is a property setter.
Get a PropertyInfo object from an expression of the form
x => x.P.
Type declaring the property.
The type of the property.
Expression mapping an instance of the
declaring type to the property value.
Property info.
Get the MethodInfo for a method called in the
expression.
Type on which the method is called.
Expression demonstrating how the method appears.
The method info for the called method.
Gets the for the new operation called in the expression.
The type on which the constructor is called.
Expression demonstrating how the constructor is called.
The for the called constructor.
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 provided expression must be of the form () =>new X(), but the provided expression was {0}..
Looks up a localized string similar to The provided expression must be of the form x =>x.M(), but the provided expression was {0}..
Looks up a localized string similar to The provided expression must be of the form x =>x.P, but the provided expression was {0}..
Adapts an action to the interface.
Initializes a new instance of the class.
The action to execute on disposal.
A factory that retrieves the value on which the
should be executed.
Provides extension methods for working with sequences.
Joins the strings into one single string interspersing the elements with the separator (a-la
System.String.Join()).
The elements.
The separator.
The joined string.
Appends the item to the specified sequence.
The type of element in the sequence.
The sequence.
The trailing item.
The sequence with an item appended to the end.
Prepends the item to the specified sequence.
The type of element in the sequence.
The sequence.
The leading item.
The sequence with an item prepended.
Add a set of items to the given collection.
The set type.
The collection to add to.
The set of items to add.
Provides access to a unique sequenced number.
Get the next unique sequence value.
A new sequence value.
Provides a method to support traversing structures.
Traverse across a set, taking the first item in the set, and a function to determine the next item.
The set type.
The first item in the set.
A callback that will take the current item in the set, and output the next one.
An enumerable of the set.
Provides helper methods for manipulating and inspecting types.
For a delegate type, outputs the return type of the delegate.
The delegate type.
The delegate return type.
Determine whether a given type is an open generic.
The input type.
True if the type is an open generic; false otherwise.
Returns the first concrete interface supported by the candidate type that
closes the provided open generic service type.
The type that is being checked for the interface.
The open generic type to locate.
The type of the interface.
Checks whether this type is a closed type of a given generic type.
The type we are checking.
The open generic type to validate against.
True if is a closed type of . False otherwise.
Determines whether a given generic type definition is compatible with the specified type parameters (i.e. is it possible to create a closed generic type from those parameters).
The generic type definition.
The set of parameters to check against.
True if the parameters match the generic parameter constraints.
Checks whether a type is compiler generated.
The type to check.
True if the type is compiler generated; false otherwise.
Checks whether a given type is a delegate type.
The type to check.
True if the type is a delegate; false otherwise.
Checks whether a given type is a generic enumerable interface type, e.g. , , , etc.
The type to check.
True if the type is one of the supported enumerable interface types.
Checks whether a given type is a generic list of colleciton interface type, e.g. , and the read-only variants.
The type to check.
True if the type is one of the supported list/collection types.
Checks whether a given type is a closed generic defined by the specifed open generic.
The type to check.
The open generic to check against.
True if the type is defined by the specified open generic; false otherwise.
Checks whether this type is an open generic type of a given type.
The type we are checking.
The type to validate against.
True if is a open generic type of . False otherwise.
Looks for an interface on the candidate type that closes the provided open generic interface type.
The type that is being checked for the interface.
The open generic service type to locate.
True if a closed implementation was found; otherwise false.
Signal attribute for static analysis that indicates a helper method is
validating arguments for .