NG0202: This constructor is not compatible with Angular Dependency Injection because its dependency at index 0 of the parameter list is invalid.
Un parametru din constructor are un tip pe care Angular nu-l poate folosi ca cheie: de obicei o interfață sau un tip care dispare la rulare. Folosește o clasă (abstractă sau concretă) ori un InjectionToken, sau înlocuiește injectarea din constructor cu inject().
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Angular injectează parametrii din constructor după tipul lor, pe care îl citește din metadatele generate de TypeScript. Interfețele, tipurile (type X = ...) și uniunile nu există la rulare: în locul lor, metadatele conțin Object sau undefined. Când parametrul de pe poziția din mesaj („at index 0”) nu are un tip valid, Angular aruncă NG0202.
Numărul din mesaj este poziția parametrului, numărând de la 0: index 0 = primul parametru, index 1 = al doilea. Restul mesajului dă și alte motive posibile: tipul este primitiv (string) sau o clasă părinte nu are decorator Angular (@Injectable, @Component).
Reparațiile tipice: transformi interfața într-o clasă abstractă (care există la rulare și poate fi cheie), folosești un InjectionToken cu @Inject(TOKEN) sau, mai simplu în Angular modern, renunți la injectarea în constructor și scrii private log = inject(LOGGER);.
De ce apare: cauzele frecvente
1Interfață ca tip de dependență
interface Logger { scrie(m: string): void; }
@Injectable({ providedIn: 'root' })
export class CosService {
constructor(private log: Logger) {}
}export abstract class Logger { abstract scrie(m: string): void; }
@Injectable({ providedIn: 'root' })
export class CosService {
private log = inject(Logger);
}
// providers: [{ provide: Logger, useClass: ConsolaLogger }]O clasă abstractă există la rulare, deci poate fi cheia providerului. Interfața dispare la compilare și nu poate fi căutată în injector.
2Clasa părinte fără decorator
export class Baza {
constructor(protected http: HttpClient) {}
}
@Injectable({ providedIn: 'root' })
export class Produse extends Baza { }@Injectable()
export abstract class Baza {
protected http = inject(HttpClient);
}
@Injectable({ providedIn: 'root' })
export class Produse extends Baza { }Fără decorator pe clasa părinte, Angular nu are metadatele constructorului ei. Cu inject() în câmp, moștenirea nu mai depinde de constructor.
Repară eroarea, direct în pagină
CosService primește un Logger prin constructor, dar Logger e o interfață, iar aplicația se oprește cu NG0202. Transformă Logger într-o clasă abstractă, oferă implementarea ConsolaLogger cu useClass și ia dependența cu inject(Logger). p#mesaj trebuie să afișeze „Coș salvat”.
import { Component, Injectable, inject } from '@angular/core';
interface Logger { scrie(m: string): string; }
export class ConsolaLogger implements Logger {
scrie(m: string) { return m; }
}
@Injectable({ providedIn: 'root' })
export class CosService {
constructor(private log: Logger) {}
salveaza() { return this.log.scrie('Coș salvat'); }
}
@Component({
selector: 'app-root',
providers: [ConsolaLogger],
template: `<p id="mesaj">{{ cos.salveaza() }}</p>`
})
export class App {
cos = inject(CosService);
}Indiciu
O clasă abstractă poate fi cheie în providers; o interfață nu.
Reparația
import { Component, Injectable, inject } from '@angular/core';
export abstract class Logger { abstract scrie(m: string): string; }
export class ConsolaLogger implements Logger {
scrie(m: string) { return m; }
}
@Injectable()
export class CosService {
private log = inject(Logger);
salveaza() { return this.log.scrie('Coș salvat'); }
}
@Component({
selector: 'app-root',
providers: [CosService, { provide: Logger, useClass: ConsolaLogger }],
template: `<p id="mesaj">{{ cos.salveaza() }}</p>`
})
export class App {
cos = inject(CosService);
}De ce merge
Interfața Logger dispare la compilare, așa că Angular nu știa ce să injecteze pe poziția 0 a constructorului și a aruncat NG0202.
Clasa abstractă Logger există la rulare și devine cheia din providers. { provide: Logger, useClass: ConsolaLogger } spune că, pentru cheia Logger, se creează un ConsolaLogger. Serviciul ia dependența cu inject(Logger), fără constructor. Fiindcă Logger e oferit la componentă, și CosService e pus în aceleași providers, ca să-l poată vedea.
Alte forme ale mesajului
Error: NG0202: This constructor is not compatible with Angular Dependency Injection because its dependency at index 1 of the parameter list is invalid. This can happen if the dependency type is a primitive like a string or if an ancestor of this class is missing an Angular decorator.
Cum o eviți pe viitor
- Folosește
inject()în câmpuri în loc de parametri în constructor: nu mai depinzi de metadatele tipurilor. - Pentru „contracte” între servicii folosește clase abstracte sau
InjectionToken, nu interfețe. - Pune
@Injectable()și pe clasele de bază care au dependențe.
Întrebări frecvente
De ce interfața merge peste tot în TypeScript, dar nu aici?
TypeScript folosește interfețele doar la compilare, pentru verificarea tipurilor, apoi le șterge. Injectorul lucrează la rulare și are nevoie de o valoare reală (o clasă sau un token) ca să caute providerul.
Ce înseamnă „at index 0”?
Poziția parametrului problematic în constructor, numărată de la 0. Dacă ai constructor(a: A, b: Logger), index 1 arată spre b.
Erori înrudite
NG0201: No provider found for `String`. Source: Environment Injector. Path: CosService -> String. Constructorul unui serviciu are un parametru de tip string (sau number), iar Angular încearcă să-l injecteze ca pe o dependență. Valorile simple nu se injectează așa: fă parametrul un câmp cu valoare implicită sau folosește un InjectionToken. NG0204: Can't resolve all parameters for CosService: (?). Angular nu poate citi tipurile parametrilor din constructorul unei clase, de obicei pentru că îi lipsește decoratorul @Injectable() sau pentru că un import circular face ca tipul să fie undefined. Pune @Injectable() pe clasă sau folosește inject() în câmpuri. error TS2693: 'Logger' only refers to a type, but is being used as a value here. Ai folosit o interfață sau un type ca valoare, de obicei în inject(Logger) sau în providers: [Logger]. Tipurile dispar la rulare, deci nu pot fi chei pentru injector: folosește o clasă (abstractă) sau un InjectionToken. Învață Angular de la zero, cu exerciții la fiecare lecție
Curs Angular: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
