Angular Advanced DI

Angular Advanced Dependency Injection उन scenarios को cover करता है जहाँ simple providedIn: 'root' और basic providers sufficient नहीं होते। Large-scale applications, enterprise systems और highly configurable architectures में Angular DI के advanced features का deep understanding जरूरी होता है।

इस chapter में हम Angular Advanced DI को hierarchy, resolution control, advanced tokens और real-world patterns के साथ detail में समझेंगे।

Hierarchical Injectors Deep Dive

Angular का DI system hierarchical होता है। इसका मतलब है कि हर injector का एक parent होता है।

Injector levels:

• Root Injector
• Environment Injector
• Component Injector

जब Angular किसी dependency को resolve करता है, तो वह:

• Current injector से start करता है
• Parent injectors में climb करता है
• Root तक search करता है

यह behavior advanced DI patterns की foundation है।

Environment Injector

Modern Angular में Environment Injector introduced हुआ है।

Use cases:

• Standalone APIs
• Feature-level providers
• Lazy-loaded configurations

bootstrapApplication(AppComponent, {
  providers: [AuthService]
});

यह providers application environment scope में register करता है।

Injector Resolution Control

Angular decorators के through resolution control allow करता है।

@Self

Dependency सिर्फ current injector से resolve होगी।

constructor(@Self() private service: LocalService) {}

Parent injector में service होने पर भी use नहीं होगी।

@SkipSelf

Current injector skip करके parent से resolve करता है।

constructor(@SkipSelf() private parentService: ParentService) {}

@Host

Resolution host component तक limited करता है।

constructor(@Host() private hostService: HostService) {}

Complex component trees में helpful है।

@Optional

Dependency optional बनाता है।

constructor(@Optional() private logger?: LoggerService) {}

Provider missing होने पर error नहीं आएगा।

Injector Tree Override Patterns

Child component parent provider को override कर सकता है।

@Component({
  providers: [
    { provide: LoggerService, useClass: DebugLogger }
  ]
})

यह pattern feature-level customization के लिए use होता है।

Custom Injector Creation

Rare cases में manually injector create किया जा सकता है।

const injector = Injector.create({
  providers: [
    { provide: ApiService, useClass: ApiService }
  ]
});

Use cases:

• Dynamic plugin systems
• Isolated logic execution

Manual injector advanced और careful usage demand करता है।

inject() Function (Modern DI)

Angular में constructor-less injection possible है।

const api = inject(ApiService);

Use cases:

• Functional guards
• Standalone utilities
• Signals-based logic

यह functional programming patterns को enable करता है।

DI in Functional APIs

Guards example:

export const authGuard = () => {
  const auth = inject(AuthService);
  return auth.isLoggedIn();
};

Modern Angular APIs heavily use inject().

Multi Providers Advanced Pattern

Multi providers execution pipeline बना सकते हैं।

export const HANDLERS = new InjectionToken<Handler[]>('HANDLERS');

providers: [
  { provide: HANDLERS, useClass: AHandler, multi: true },
  { provide: HANDLERS, useClass: BHandler, multi: true }
]

यह plugin-based architecture enable करता है।

Aliasing Providers

Same instance को different tokens से expose करना।

providers: [
  { provide: OldService, useExisting: NewService }
]

Backward compatibility में helpful है।

Lazy-Loaded Modules और DI

Lazy-loaded modules का अपना injector होता है।

Effects:

• Services isolate हो सकती हैं
• State duplication हो सकता है

providedIn: 'any'

इससे हर lazy module को new instance मिलता है।

Tree-Shakable Advanced Providers

Advanced provider options:

@Injectable({ providedIn: 'platform' })

Scopes:

• root
• platform
• any

यह advanced bundle optimization में use होता है।

DI with Configuration Objects

Complex config DI pattern:

export interface FeatureConfig {
  enabled: boolean;
}

export const FEATURE_CONFIG =
  new InjectionToken<FeatureConfig>('FEATURE_CONFIG');

यह configuration-driven apps के लिए ideal है।

Circular Dependency Detection

Angular runtime पर circular dependencies detect करता है।

Symptoms:

• Injection errors
• App bootstrap failure

Solutions:

• Shared abstraction layer
• Factory-based indirection
• Logic refactoring

Performance Considerations

DI misuse performance impact डाल सकता है।

Best practices:

• Unnecessary providers avoid करें
• Component-level providers limited रखें
• Singleton services prefer करें
• Multi providers heavy logic से बचें

Testing Insight (DI Perspective)

Testing में DI powerful role play करता है।

providers: [
  { provide: ApiService, useClass: MockApiService }
]

DI test isolation और mocking को simple बनाता है।

Common Advanced DI Mistakes

• Overusing component-level providers
• Circular provider chains
• Using string tokens
• Global state accidentally duplicating

Real-World Advanced DI Use Cases

Angular Advanced DI use होता है:

• Plugin-based systems
• Feature flag engines
• Large micro-frontend apps
• Configurable enterprise platforms

Angular Advanced DI Angular architecture का most powerful लेकिन most misused हिस्सा भी है। सही तरीके से use करने पर यह Angular applications को highly flexible और scalable बनाता है। अगले chapter में हम Angular State Management को detail में cover करेंगे, जहाँ services, signals और RxJS के साथ state patterns discuss होंगे।