Contains methods for registering and creating collections in the Container.
Inheritance Hierarchy
SimpleInjector.AdvancedApiObject
SimpleInjectorContainerCollectionRegistrator
Namespace: SimpleInjector
Assembly: SimpleInjector (in SimpleInjector.dll) Version: 5.3.0
Syntax
The ContainerCollectionRegistrator type exposes the following members.
Properties
Name | Description | |
---|---|---|
Container |
Gets the Container for this instance.
|
Methods
Name | Description | |
---|---|---|
Append(Type, Registration) |
Appends a new registration to a collection of registrations for the given
serviceType. Calls to Append can both preceed and follow a call to one
of the Container.Collections.Register
overloads.
| |
Append(Type, Type) |
Appends a new registration of implementationType to a collection of
registrations for the given serviceType. Calls to Append can both
preceed and follow a call to one of the
Container.Collections.Register overloads.
| |
Append(Type, Type, Lifestyle) |
Appends a new registration of implementationType to a collection of
registrations for the given serviceType using the supplied
lifestyle. Calls to Append can both preceed and follow a call to one of
the Container.Collections.Register overloads.
| |
AppendTService(FuncTService, Lifestyle) |
Appends the specified delegate instanceCreator to a collection of
registrations for the given TService using the supplied
lifestyle. Calls to Append can both preceed and follow a call to one of
the Container.Collections.Register overloads.
| |
AppendTService, TImplementation |
Appends a new registration of TImplementation to a collection of
registrations for the given TService. Calls to Append can both
preceed and follow a call to one of the
Container.Collections.Register overloads.
| |
AppendTService, TImplementation(Lifestyle) |
Appends a new registration of TImplementation to a collection of
registrations for the given TService using the supplied
lifestyle. Calls to Append can both preceed and follow a call to one of
the Container.Collections.Register overloads.
| |
AppendInstance(Type, Object) |
Appends a single instance to a collection of registrations for the given
serviceType. Calls to AppendInstance can both preceed and follow a
call to one of the
Container.Collections.Register overloads.
This instance must be thread-safe when working in a multi-threaded environment.
NOTE: Do note that instances supplied by this method NEVER get disposed by the
container; the instance is assumed to outlive this container instance. If disposing is
required, use
RegisterSingleton<TService>(Func<TService>).
| |
AppendInstanceTService(TService) |
Appends a single instance to a collection of registrations for the given
TService . Calls to AppendInstance can both preceed and follow a
call to one of the
Container.Collections.Register overloads.
This instance must be thread-safe when working in a multi-threaded environment.
NOTE: Do note that instances supplied by this method NEVER get disposed by the
container; the instance is assumed to outlive this container instance. If disposing is
required, use
RegisterSingleton<TService>(Func<TService>).
| |
CreateTService(IEnumerableAssembly) |
Creates a collection of
all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given TService
with a default lifestyle and register them as a collection of TService.
Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
| |
CreateTService(IEnumerableType) |
Creates a collection of serviceTypes, whose instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateTService(Assembly) |
Creates a collection of
all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given TService
with a default lifestyle and register them as a collection of TService.
Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
| |
CreateTService(Type) |
Creates a collection of serviceTypes, whose instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateTService(Registration) |
Creates a collection of registrations, whose instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateTService(IEnumerableRegistration) |
Creates a collection of registrations, whose instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateRegistrationTService(IEnumerableAssembly) |
Creates a new Registration instance defining the creation of a collection of
all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given TService
with a default lifestyle and register them as a collection of TService.
Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
The collection's instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateRegistrationTService(IEnumerableType) |
Creates a new Registration instance defining the creation of a collection of
serviceTypes, whose instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateRegistrationTService(Assembly) |
Creates a new Registration instance defining the creation of a collection of
all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given TService
with a default lifestyle and register them as a collection of TService.
Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
The collection's instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateRegistrationTService(Type) |
Creates a new Registration instance defining the creation of a collection of
serviceTypes, whose instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateRegistrationTService(Registration) |
Creates a new Registration instance defining the creation of a collection of
registrations, whose instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
CreateRegistrationTService(IEnumerableRegistration) |
Creates a new Registration instance defining the creation of a collection of
registrations, whose instances will be resolved lazily
each time the returned collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
Equals | Determines whether the specified object is equal to the current object. (Inherited from ApiObject.) | |
GetHashCode | Serves as the default hash function. (Inherited from ApiObject.) | |
GetType | Gets the Type of the current instance. (Inherited from ApiObject.) | |
Register(Type, IEnumerableRegistration) |
Registers a collection of registrations, whose instances will be resolved lazily
each time the resolved collection of serviceType is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
Register(Type, IEnumerableAssembly) |
Registers all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given serviceType
with a default lifestyle and register them as a collection of serviceType.
Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
Composites,
decorators and
generic type definitions
will be excluded from registration.
| |
Register(Type, IEnumerableType) |
Registers a collection of serviceTypes, whose instances will be resolved lazily
each time the resolved collection of serviceType is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
Register(Type, IEnumerable) |
Registers a dynamic (container uncontrolled) collection of elements of type
serviceType. A call to GetAllInstancesTService will return the
containerUncontrolledCollection itself, and updates to the collection will be
reflected in the result. If updates are allowed, make sure the collection can be iterated safely
if you're running a multi-threaded application.
| |
Register(Type, Assembly) |
Registers all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given serviceType
with a default lifestyle and register them as a collection of serviceType.
Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
Composites,
decorators and
generic type definitions
will be excluded from registration.
| |
Register(Type, IEnumerableAssembly, Lifestyle) |
Registers all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given serviceType
with the supplied lifestyle and register them as a collection of
serviceType. Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
Composites,
decorators and
generic type definitions
will be excluded from registration.
| |
Register(Type, IEnumerableType, Lifestyle) |
Registers a collection of serviceTypes, whose instances will be resolved lazily
each time the resolved collection of serviceType is enumerated.
The underlying collection is a stream that will return individual instances based on the supplied
lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
RegisterTService(IEnumerableAssembly) |
Registers all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given TService
with a default lifestyle and register them as a collection of TService.
Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
| |
RegisterTService(IEnumerableType) |
Registers a collection of serviceTypes, whose instances will be resolved lazily
each time the resolved collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
RegisterTService(IEnumerableTService) |
Registers a dynamic (container uncontrolled) collection of elements of type
TService. A call to GetAllInstancesTService will return the
containerUncontrolledCollection itself, and updates to the collection will be
reflected in the result. If updates are allowed, make sure the collection can be iterated safely
if you're running a multi-threaded application.
| |
RegisterTService(Assembly) |
Registers all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given TService
with a default lifestyle and register them as a collection of TService.
Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
| |
RegisterTService(Type) |
Registers a collection of serviceTypes, whose instances will be resolved lazily
each time the resolved collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
RegisterTService(TService) |
Registers a collection of singleton elements of type TService.
| |
RegisterTService(IEnumerableRegistration) |
Registers a collection of registrations, whose instances will be resolved lazily
each time the resolved collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on their
specific registered lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
RegisterTService(IEnumerableAssembly, Lifestyle) |
Registers all concrete, non-generic types (both public and internal) that are defined in the given
set of assemblies and that implement the given TService
with the supplied lifestyle and register them as a collection of
TService. Unless overridden using a custom
LifestyleSelectionBehavior, the
default lifestyle is Transient.
| |
RegisterTService(IEnumerableType, Lifestyle) |
Registers a collection of serviceTypes, whose instances will be resolved lazily
each time the resolved collection of TService is enumerated.
The underlying collection is a stream that will return individual instances based on the supplied
lifestyle, for each call to Current.
The order in which the types appear in the collection is the exact same order that the items were
supplied to this method, i.e the resolved collection's order is deterministic.
| |
ToString | Returns a string that represents the current object. (Inherited from ApiObject.) |
See Also