ReflectiveInjector
class
deprecated
A ReflectiveDependency injection container used for instantiating objects and resolving dependencies.
Deprecated: from v5 - slow and brings in a lot of code, Use Injector.create
instead.
abstract class ReflectiveInjector implements Injector {
static resolve(providers: Provider[]): ResolvedReflectiveProvider[]
static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector
static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector): ReflectiveInjector
abstract parent: Injector | null
abstract resolveAndCreateChild(providers: Provider[]): ReflectiveInjector
abstract createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector
abstract resolveAndInstantiate(provider: Provider): any
abstract instantiateResolved(provider: ResolvedReflectiveProvider): any
abstract get(token: any, notFoundValue?: any): any
}
Description
An Injector
is a replacement for a new
operator, which can automatically resolve the constructor dependencies.
In typical use, application code asks for the dependencies in the constructor and they are resolved by the Injector
.
Static methods
resolve() | |||
---|---|---|---|
Turns an array of provider definitions into an array of resolved providers. | |||
static resolve(providers: Provider[]): ResolvedReflectiveProvider[]Parameters
Returns
| |||
A resolution is a process of flattening multiple nested arrays and converting individual providers into an array of ResolvedReflectiveProvider s.
| |||
Usage NotesExample
|
resolveAndCreate() | ||||||
---|---|---|---|---|---|---|
Resolves an array of providers and creates an injector from those providers. | ||||||
static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjectorParameters
Returns
| ||||||
The passed-in providers can be an array of Type , Provider , or a recursive array of more providers.
| ||||||
Usage NotesExample
|
fromResolvedProviders() | ||||||
---|---|---|---|---|---|---|
Creates an injector from previously resolved providers. | ||||||
static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector): ReflectiveInjectorParameters
Returns
| ||||||
This API is the recommended way to construct injectors in performance-sensitive parts. | ||||||
Usage NotesExample
|
Properties
Property | Description |
---|---|
null |
Read-only. Parent of this injector. |
Methods
resolveAndCreateChild() | |||
---|---|---|---|
Resolves an array of providers and creates a child injector from those providers. | |||
abstract resolveAndCreateChild(providers: Provider[]): ReflectiveInjectorParameters
Returns
| |||
The passed-in providers can be an array of Type , Provider , or a recursive array of more providers.
| |||
Usage NotesExample
|
createChildFromResolved() | |||
---|---|---|---|
Creates a child injector from previously resolved providers. | |||
abstract createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjectorParameters
Returns
| |||
This API is the recommended way to construct injectors in performance-sensitive parts. | |||
Usage NotesExample
|
resolveAndInstantiate() | |||
---|---|---|---|
Resolves a provider and instantiates an object in the context of the injector. | |||
abstract resolveAndInstantiate(provider: Provider): anyParameters
Returns
| |||
The created object does not get cached by the injector. | |||
Usage NotesExample
|
instantiateResolved() | |||
---|---|---|---|
Instantiates an object using a resolved provider in the context of the injector. | |||
abstract instantiateResolved(provider: ResolvedReflectiveProvider): anyParameters
Returns
| |||
The created object does not get cached by the injector. | |||
Usage NotesExample
|
get() | ||||||
---|---|---|---|---|---|---|
abstract get(token: any, notFoundValue?: any): anyParameters
Returns
|
Usage notes
Example
The following example creates an Injector
configured to create Engine
and Car
.
@Injectable()
class Engine {
}
@Injectable()
class Car {
constructor(public engine:Engine) {}
}
var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
var car = injector.get(Car);
expect(car instanceof Car).toBe(true);
expect(car.engine instanceof Engine).toBe(true);
Notice, we don't use the new
operator because we explicitly want to have the Injector
resolve all of the object's dependencies automatically.
© 2010–2019 Google, Inc.
Licensed under the Creative Commons Attribution License 4.0.
https://v7.angular.io/api/core/ReflectiveInjector