Dependency Injection અને Inversion of Control શું છે?

Question

Accepted Answer

**Dependency Injection (DI)** એટલે કે અમુક વસ્તુ તેના આश્રિતી બાહ્ય સ્ત્રોતથી મેળવે છે એટલે કે તેને પોતે બનાવતી નથી. તે **Inversion of Control (IoC)** નું એક સ્વરૂપ છે: વસ્તુઓને જોડવાની જવાબદારી *ઉલટી* છે, વસ્તુ પાસેથી આમંત્રણ અથવા કન્ટેનરને આપવામાં આવે છે.

## DI વિના વિ. DI સાથે

```python
# WITHOUT DI — the class controls its own dependencies (tight coupling)
class OrderService:
    def __init__(self):
        self.repo = PostgresOrderRepo()   # hard-wired; can't swap or test

# WITH DI — dependencies are passed in (loose coupling)
class OrderService:
    def __init__(self, repo: OrderRepo):  # any OrderRepo implementation
        self.repo = repo

# wiring happens outside:
service = OrderService(PostgresOrderRepo())   # prod
test    = OrderService(InMemoryOrderRepo())   # test — no DB needed
```

વર્ગ હવે *અમૂર્તતા* `OrderRepo` પર આધારિત છે, અને કોઈ બીજું નક્કી કરે છે કે કયું મૂર્ત પ્રદાન કરવું.

## ઇંજેક્શનના સ્વરૂપો

| સ્વરૂપ | કેવી રીતે |
|---|---|
| કન્સ્ટ્રક્ટર | કન્સ્ટ્રક્ટરને પાસ કર્યું (પસંદ કરેલું — જરૂરી આશ્રિતી સ્પષ્ટ) |
| સેટર | કોન્સ્ટ્રક્શન પછી પદ્ધતિ દ્વારા સેટ કર્યું (વૈકલ્પિક આશ્રિતી) |
| ઇન્ટરફેસ/કન્ટેનર | ફ્રેમવર્ક ઉકેલ અને ઇંજેક્ટ કરે છે (Spring, .NET DI) |

## સમજોતો

```text
✓ Testable (inject fakes/mocks)   ✓ Swappable implementations
✓ Explicit dependencies            ⚠️ More wiring; indirection can obscure flow
⚠️ DI containers add "magic" → harder to trace what's wired where
```

## શા માટે તે મહત્વપૂર્ણ છે

DI એ Dependency Inversion Principle નું વ્યવહારિક સાક્ષ્य છે — ઉચ્ચ-સ્તરનો તર્ક ઠોસ, નીચલા-સ્તરના વર્ગો પર આધારિત નથી રહે.

લાભ પરીક્ષણીયતા અને લવચકતા છે: તમે પરીક્ષણોમાં નકલી ડેટાબેસ અથવા ઉત્પાદનમાં ચુકવણી પ્રદાતાને બદલી શકો છો, જોડણી બદલીને, ન કે ব્યવસાય તર્કમાં.

સ્વરૂપ	કેવી રીતે
કન્સ્ટ્રક્ટર	કન્સ્ટ્રક્ટરને પાસ કર્યું (પસંદ કરેલું — જરૂરી આશ્રિતી સ્પષ્ટ)
સેટર	કોન્સ્ટ્રક્શન પછી પદ્ધતિ દ્વારા સેટ કર્યું (વૈકલ્પિક આશ્રિતી)
ઇન્ટરફેસ/કન્ટેનર	ફ્રેમવર્ક ઉકેલ અને ઇંજેક્ટ કરે છે (Spring, .NET DI)