Angular இல் சேவைகள் (services) மற்றும் dependency injection என்றால் என்ன?

Question

Accepted Answer

**சேவை** என்பது **UI அல்லாத தர்க்கம்** — தரவு பெறுதல், வணிக விதிகள், பகிரப்பட்ட நிலை, உள்நுழைவு — க்கான ஒரு வகுப்பு ஆகும், இதை கூறுகள் மீண்டும் பயன்படுத்தலாம். **Dependency Injection (DI)** என்பது Angular இந்த சேவைகளை தேவைப்படும் கூறுகளுக்கு *வழங்கும்* வழி, கூறுகள் அவற்றை கைமுறையாக உருவாக்குவதற்கு பதிலாக.

## சேவையை வரையறுத்தல்

```ts
import { Injectable } from "@angular/core";

@Injectable({ providedIn: "root" }) // makes it a singleton available app-wide
export class UserService {
  private users = [];
  getUsers() { return this.users; }
  addUser(u) { this.users.push(u); }
}
```

`@Injectable({ providedIn: "root" })` decorator Angular DI முறைமையுடன் சேவையை முழு பயன்பாட்டிற்கான ஒரு ஒক்க பகிரப்பட்ட நிலை (singleton) ஆக பதிவு செய்கிறது.

## ஒரு கூறுக்கு ஊசி செலுத்துதல்

```ts
@Component({ ... })
export class UserListComponent {
  // Angular sees this constructor param and INJECTS the singleton automatically
  constructor(private userService: UserService) {}

users = this.userService.getUsers(); // just use it
}
```

நீங்கள் சேவையை ஒரு constructor அளவுரு என்று பிரகடனம் செய்கிறீர்கள்; Angular DI **உருவாக்கி வழங்குகிறது** நிலை. நீங்கள் `new UserService()` என்று எழுதவே இல்லை. (நவீன Angular மாறாக constructor injection க்கு பதிலாக `inject()` செயல்பாடு பயன்படுத்தலாம்.)

```ts
import { inject } from "@angular/core";
export class UserListComponent {
  private userService = inject(UserService); // alternative injection style
}
```

## DI ஏன் மதிப்பবান

```text
✓ Single source of truth — one shared UserService instance across components
✓ Loose coupling — components depend on the type, not on constructing it
✓ Testability — swap in a mock service in tests easily
✓ Lifecycle management — Angular handles creation and sharing
```

கூறு அதன் சார்புகளை உருவாக்காது என்பதால், நீங்கள் சோதனையில் **போலி** சேவையை செலுத்தலாம், அல்லது பயன்பாடு முழுவதும் ஒரு இடத்தில் செயல்படுத்தல் மாற்றலாம்.

## இது ஏன் முக்கியம்

சேவைகள் + DI Angular கட்டடக்கலைக்கு மையமாக உள்ளன: கூறுகள் UI மீது கவனம் செலுத்தி இருக்கையில் சேவைகள் தர்க்கம் மற்றும் நிலையை வைத்திருக்கிறது, மற்றும் DI அவற்றை குறைந்தபட்ச இணைப்புடன் இணைக்கிறது.

இந்த பிரிவு (மற்றும் கொண்டுவரும் சோதனை திறன்) Angular இன் வரையறுக்கும் வலிமைகளில் ஒன்று — backend frameworks இல் இருந்து கடன் வாங்கிய — மற்றும் `@Injectable({ providedIn: 'root' })` ஒரு பகிரப்பட்ட, ஊசி செலுத்தக்கூடிய singleton க்கான இன்றைய மாதிரி.