Angular இன் தொடரியல் சார்பு உபசரण எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Angular இன் DI **தொடரியல்**: injectors ஒரு மரத்தை உருவாக்குகிறது, இது component/module மரத்தை பிரதிபலிக்கிறது. ஒரு component சார்பை கோரும்போது, Angular injector மரத்திற்கு **மேல்** நடை செய்கிறது ஒரு provider கண்டுபிடிக்கும் வரை — இது நீங்கள் ஒரு பகிரப்பட்ட singleton அல்லது ஒரு component க்கான தனிப்பட்ட instance பெறுகிறீர்களா என்பதை கட்டுப்படுத்துகிறது. ## Injector தொடரியல் ```text Root injector (app-wide) ← providedIn: 'root' lives here (one singleton) └─ Module/Route injectors └─ Component injector ← providers: [...] in @Component └─ Child component injector ``` ஒரு lookup கோரும் component இல் தொடங்கி root வரை குமிழ் மேல் செல்கிறது. **முதல்** கண்டுபிடிக்கப்பட்ட provider வெற்றியடைகிறது. ## எங்கு நீங்கள் வழங்குகிறீர்கள் என்பது வரம்பை தீர்மானிக்கிறது ```ts // 1. App-wide singleton — ONE instance shared everywhere @Injectable({ providedIn: "root" }) export class AuthService {} // 2. Component-scoped — a NEW instance per component (and its children) @Component({ selector: "app-widget", providers: [DataService], // each gets its OWN DataService }) export class WidgetComponent {} ``` இதுவே முக்கிய control: `providedIn: 'root'` ஒரு ஒற்றை பகிரப்பட்ட instance தருகிறது; component இன் `providers` array இல் ஒரு provider பட்டியலிடுவது அந்த component subtree க்கு வரம்புறுத்தப்பட்ட ஒரு புதிய instance உருவாக்குகிறது (component க்கு state ஆலோசனை செய்வதற்கு பயனுள்ளது). ## Injection மாற்றிகள் ```ts constructor( @Optional() private logger: Logger, // null instead of error if not provided @Self() private local: LocalService, // only look in THIS injector @SkipSelf() private parent: ParentService, // skip self, start at the parent @Host() private host: HostService, // stop at the host component ) {} ``` இந்த decorators injector மரத்தை Angular எவ்வளவு தூரம் தேடுகிறது என்பதைக் கட்டுப்படுத்துகிறது — உதாரணமாக `@Optional` ஒரு சார்பு காணப்படாதபோது ஒரு பிழை தவிர்கிறது, `@SkipSelf` பெற்றோரின் instance ஐ பயன்படுத்த கட்டாயப்படுத்துகிறது. ## Non-class சார்பு க்கான Injection tokens ```ts export const API_URL = new InjectionToken("apiUrl"); // provide: { provide: API_URL, useValue: "https://api.example.com" } constructor(@Inject(API_URL) private apiUrl: string) {} ``` Tokens உங்களை values/config (வெறுமனே classes அல்ல) உபचாரம் செய்ய மற்றும் செயல்பாடுகளை மாற்ற அனுமதிக்கிறது (`useClass`, `useValue`, `useFactory`). ## ஏன் இது முக்கியம் તhierarchical injector ஐ புரிந்துகொள்வது எப்போது ஒரு service முழு app இல் பகிரப்படுகிறது vs component க்கு நகல் செய்யப்படுகிறது என்பதை விளக்குகிறது — "இந்த components state ஐ பகிரும்/பகிரவில்லை ஏன்?" குழப்பத்தின் அடிக்கடி மூலமாக। Provider வரம்பை கட்டுப்படுத்துதல் (`root` vs component `providers`), மாற்றிகளைப் பயன்படுத்துதல் (`@Optional`, `@SkipSelf`), மற்றும் config/swappable implementations க்கான injection tokens என்பது Angular இன் DI ஐ architecture மற்றும் testing க்கு சக்திசாலியாக்குவது.