iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Angular error NG0203 means a call to inject() ran when no injection context was active. Move the call to a supported location—usually a DI-managed class field initializer or constructor—or, for a later lookup, use a saved Injector. The issue is where and when injection runs, not a missing provider. See Angular’s NG0203 error page.
What NG0203 means
Angular makes the current injector available only while code is executing in an injection context. Calling inject() outside that window triggers NG0203. A missing provider is a different problem: NG0203 indicates that the call site is invalid, not that Angular could not find a provider for the requested token.
Angular documents injection contexts in its dependency injection context guide and inject API reference.
Recommended Free Tools
Where you can call inject()
- During DI-managed class construction: in the constructor or in a field initializer of a class instantiated by Angular’s dependency injection system.
- In provider and token factories: inside a provider’s
useFactoryfunction or anInjectionTokenfactory. - In framework-provided injection contexts: some Angular APIs invoke callbacks in context; functional route guards are one example.
- In an explicit synchronous context: inside the callback passed to
runInInjectionContext(injector, callback).
A class field initializer is valid only when Angular is creating the class through DI. Instantiating the class yourself with new does not provide that context.
#1 Best Overall
Why methods, lifecycle hooks, and async callbacks fail
Injection context is not a permanent property of a class or function. It applies while Angular is executing code at a supported call site. An instance method called later—including ngOnInit—does not automatically have access to that context. Nor does a callback scheduled with setTimeout or Promise.then, or code that resumes after await.
For example, this is too late:
export class ExampleComponent {
ngOnInit() {
const service = inject(MyService); // NG0203
}
}Capture the dependency while the component is being constructed instead:
export class ExampleComponent {
private readonly service = inject(MyService);
ngOnInit() {
this.service.load();
}
}This works when Angular creates ExampleComponent through DI. Angular’s error guidance recommends moving the call to an allowed place, usually a constructor or field initializer; see NG0203.
Choose the right fix for later work
Capture the service during construction
If a method or callback only needs to use a dependency later, retrieve it while the class is in context and keep the reference. This is the simplest option for ordinary class behavior.
Rank #3
Use a saved Injector for deferred lookup
If you need to resolve a token later rather than retain the service itself, capture an Injector during construction and call get() when the later code runs:
export class ExampleComponent {
private readonly injector = inject(Injector);
loadLater() {
const service = this.injector.get(MyService);
service.load();
}
}Here inject(Injector) runs in the field initializer, while injector.get(MyService) performs the deferred lookup. Angular’s DI debugging and troubleshooting guide describes this approach for delayed work.
Use runInInjectionContext when the callback must call inject()
If a callback is intentionally written to use inject(), pass it to runInInjectionContext with an injector:
const injector = inject(Injector);
runInInjectionContext(injector, () => {
const service = inject(MyService);
service.load();
});The surrounding code must itself obtain injector in a valid context. The explicit context lasts only while the callback runs synchronously. It does not extend into an asynchronous callback or beyond an await; Angular states this limitation in its runInInjectionContext API reference.
Use the injection-context helper in tests
When a test needs to call code that uses inject(), run that code through TestBed.runInInjectionContext so it executes with the testing environment’s injector:
TestBed.runInInjectionContext(() => {
const service = inject(MyService);
// Assertions or other synchronous test work
});See Angular’s TestBed API reference. As with the general helper, keep calls to inject() inside the synchronous callback.
Quick Recap
Find the call that caused the error
- Read the NG0203 stack trace and locate the first application call site that invokes
inject(), directly or through a helper. - Check whether that code is running during DI-managed construction, in a factory, or inside an Angular-provided or explicitly established injection context.
- If it runs in a method, lifecycle hook, timer, promise callback, or after
await, move dependency retrieval earlier or use a savedInjectorfor deferred lookup. - If a reusable helper requires a caller-provided injection context, add
assertInInjectionContext(helperFunction)so misuse fails with a clearer explanation. Angular documents this in the injection context guide.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →
