In Angular, where does an injection context exist, and why does calling inject() inside ngOnInit throw NG0203?

## What an injection context is The `inject()` function takes a token but no injector. To resolve the token it needs to know *which* injector to ask — the component's element injector, a route's environment injector, the root. Angular keeps that answer in an internal "current injector" slot. The slot is filled only while Angular itself is running code that should be able to inject, and it is restored as soon as that code returns. Any stack frame running while the slot is filled is said to be in an **injection context**. This is a property of the **synchronous call stack**, not of the class or the file. The same line of code can be inside a context when called from a constructor and outside one when called from a click handler. ## Where a context exists Angular's guide lists these places: 1. **Construction of a DI-created class** — the constructor of a component, directive, pipe or service that Angular instantiates. 2. **Field initializers** of such classes, which run as part of construction. 3. **Provider factories** — a `useFactory` function, or the factory of an `@Injectable`. 4. **`InjectionToken` factories** — the `factory` option of a token. 5. **Code run inside `runInInjectionContext(injector, fn)`**, for as long as `fn` runs synchronously. The fifth item is how framework APIs extend the context to plain functions. The router, for example, runs functional guards and resolvers through `runInInjectionContext` with the route's environment injector, which is why `inject(AuthService)` at the top of a `CanActivateFn` works. ## Why `ngOnInit` is outside Lifecycle hooks are ordinary method calls that change detection makes **after** the instance exists: | Moment | Context active? | `inject()` | |---|---|---| | Field initializer | yes | works | | Constructor body | yes | works | | `ngOnInit`, `ngAfterViewInit`, other hooks | no | NG0203 | | Event handler such as `(click)` | no | NG0203 | | `setTimeout`, `Promise.then`, `subscribe` callbacks | no | NG0203 | | After an `await` inside construction-time code | no | NG0203 | The development-mode message spells out the rule: "`inject()` function must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with `runInInjectionContext`". ## Fixing NG0203 - **Move the call.** In almost every case the dependency can be injected in a field initializer and used later: `private readonly router = inject(Router)` and then `this.router.navigate(...)` in the hook. - **Capture an injector when the choice is dynamic.** If the token is only known later, inject `Injector` in a field and wrap the later code in `runInInjectionContext(this.injector, () => ...)`. - **Do not reach for global workarounds.** Storing an injector in a module-level variable to call `.get()` anywhere hides dependencies and breaks when several applications or tests share a page. ## Framework APIs that open a context for you The same mechanism explains why some Angular APIs accept plain functions that call `inject()`. The router is the familiar case: it runs functional guards and resolvers inside `runInInjectionContext` with the route's environment injector, so `CanActivateFn` and `ResolveFn` bodies can call `inject()` at their top. Other APIs go the other way and *require* a context because they need an injector themselves — they read it from the current context and throw NG0203 when there is none. In both directions the rule is identical: the context covers only the synchronous body of the function being run. ## Diagnosing from the stack trace The error is thrown at the `inject()` call, so the stack trace points at the line. The useful question is *who called this frame*: - a lifecycle hook or event handler — move the call to a field; - a callback such as a timer, promise or subscription — resolve before scheduling; - a helper function — check where the helper itself was called from; helpers that call `inject()` inherit the rule and must be called at construction time. ## Why Angular works this way Making the injector ambient is what lets `inject()` be a plain function usable in fields, factories and guards without passing an injector around. The price is that the context must be well-defined, and a synchronous stack frame is the only boundary JavaScript gives Angular for free. Asynchronous callbacks run on fresh stacks, long after the slot was restored, so they cannot see it.