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 }
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
.
Further information is available in the Usage Notes...
resolve() | |||
---|---|---|---|
Turns an array of provider definitions into an array of resolved providers. | |||
|
providers | Provider[] |
A resolution is a process of flattening multiple nested arrays and converting individual providers into an array of ResolvedReflectiveProvider
s.
@Injectable() class Engine { } @Injectable() class Car { constructor(public engine:Engine) {} } var providers = ReflectiveInjector.resolve([Car, [[Engine]]]); expect(providers.length).toEqual(2); expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true); expect(providers[0].key.displayName).toBe("Car"); expect(providers[0].dependencies.length).toEqual(1); expect(providers[0].factory).toBeDefined(); expect(providers[1].key.displayName).toBe("Engine"); });
resolveAndCreate() |
---|
Resolves an array of providers and creates an injector from those providers. |
The passed-in providers can be an array of |
Usage NotesExample@Injectable() class Engine { } @Injectable() class Car { constructor(public engine:Engine) {} } var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]); expect(injector.get(Car) instanceof Car).toBe(true); |
fromResolvedProviders() | ||||||
---|---|---|---|---|---|---|
Creates an injector from previously resolved providers. | ||||||
|
providers | ResolvedReflectiveProvider[] | |
parent | Injector | Optional. Default is |
This API is the recommended way to construct injectors in performance-sensitive parts.
@Injectable() class Engine { } @Injectable() class Car { constructor(public engine:Engine) {} } var providers = ReflectiveInjector.resolve([Car, Engine]); var injector = ReflectiveInjector.fromResolvedProviders(providers); expect(injector.get(Car) instanceof Car).toBe(true);
Property | Description |
---|---|
abstract parent: Injector | null | Read-Only Parent of this injector. |
resolveAndCreateChild() | |||
---|---|---|---|
Resolves an array of providers and creates a child injector from those providers. | |||
|
providers | Provider[] |
The passed-in providers can be an array of Type
, Provider
, or a recursive array of more providers.
class ParentProvider {} class ChildProvider {} var parent = ReflectiveInjector.resolveAndCreate([ParentProvider]); var child = parent.resolveAndCreateChild([ChildProvider]); expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true); expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true); expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
createChildFromResolved() | |||
---|---|---|---|
Creates a child injector from previously resolved providers. | |||
|
providers | ResolvedReflectiveProvider[] |
This API is the recommended way to construct injectors in performance-sensitive parts.
class ParentProvider {} class ChildProvider {} var parentProviders = ReflectiveInjector.resolve([ParentProvider]); var childProviders = ReflectiveInjector.resolve([ChildProvider]); var parent = ReflectiveInjector.fromResolvedProviders(parentProviders); var child = parent.createChildFromResolved(childProviders); expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true); expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true); expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
resolveAndInstantiate() |
---|
Resolves a provider and instantiates an object in the context of the injector. |
The created object does not get cached by the injector. |
Usage NotesExample@Injectable() class Engine { } @Injectable() class Car { constructor(public engine:Engine) {} } var injector = ReflectiveInjector.resolveAndCreate([Engine]); var car = injector.resolveAndInstantiate(Car); expect(car.engine).toBe(injector.get(Engine)); expect(car).not.toBe(injector.resolveAndInstantiate(Car)); |
instantiateResolved() | |||
---|---|---|---|
Instantiates an object using a resolved provider in the context of the injector. | |||
|
provider | ResolvedReflectiveProvider |
any
The created object does not get cached by the injector.
@Injectable() class Engine { } @Injectable() class Car { constructor(public engine:Engine) {} } var injector = ReflectiveInjector.resolveAndCreate([Engine]); var carProvider = ReflectiveInjector.resolve([Car])[0]; var car = injector.instantiateResolved(carProvider); expect(car.engine).toBe(injector.get(Engine)); expect(car).not.toBe(injector.instantiateResolved(carProvider));
get() | ||||||
---|---|---|---|---|---|---|
|
token | any | |
notFoundValue | any | Optional. Default is |
any
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–2021 Google, Inc.
Licensed under the Creative Commons Attribution License 4.0.
https://v12.angular.io/api/core/ReflectiveInjector