Wat is dependency injection en inversion of control?

Question

Accepted Answer

**Dependency Injection (DI)** betekent dat een object zijn afhankelijkheden van buiten krijgt in plaats van deze zelf te creëren. Het is een vorm van **Inversion of Control (IoC)**: de verantwoordelijkheid voor het verbinden van objecten wordt *omgekeerd* weg van het object en gegeven aan een caller of container.

## Zonder DI versus met 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
```

De class is nu afhankelijk van de *abstractie* `OrderRepo`, en iemand anders bepaalt welke concrete variant moet worden geleverd.

## Waarom het belangrijk is

| Vorm | Hoe |
|---|---|
| Constructor | Meegegeven aan de constructor (voorkeur — vereiste afhankelijkheden expliciet) |
| Setter | Ingesteld via een methode na constructie (optionele afhankelijkheden) |
| Interface/container | Een framework lost op en injecteert (Spring, .NET DI) |

## Trade-offs

```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
```

## Waarom het belangrijk is

DI is de praktische realisatie van het Dependency Inversion Principle — high-level logica stopt met het afhangen van concrete, low-level classes.

De opbrengst is testbaarheid en flexibiliteit: je kunt een nep-database in tests vervangen of een betaalprovider in productie swappen door de bedrading te veranderen, niet de bedrijfslogica.

Vorm	Hoe
Constructor	Meegegeven aan de constructor (voorkeur — vereiste afhankelijkheden expliciet)
Setter	Ingesteld via een methode na constructie (optionele afhankelijkheden)
Interface/container	Een framework lost op en injecteert (Spring, .NET DI)