Vad är beroendeinjektion och inversion av kontroll?

Question

Accepted Answer

**Beroendeinjektion (DI)** innebär att ett objekt mottar sina beroenden från utsidan istället för att skapa dem själv. Det är en form av **Inversion av kontroll (IoC)**: ansvaret för att koppla samman objekt är *inverterat* bort från objektet och ges till en anropare eller behållare.

## Utan DI vs. med 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
```

Klassen är nu beroende av *abstraktionen* `OrderRepo`, och någon annan bestämmer vilken konkret version som ska tillhandahållas.

## Former av injektion

| Form | Hur |
|---|---|
| Konstruktor | Passerad till konstruktorn (föredraget — obligatoriska beroenden explicita) |
| Setter | Inställd via en metod efter konstruktion (valfria beroenden) |
| Gränssnitt/behållare | Ett ramverk löser och injicerar (Spring, .NET DI) |

## Avvägningar

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

## Varför det är viktigt

DI är den praktiska realiseringen av beroendeomvändningsprincipen — logik på höga nivåer slutar att bero på konkreta, lågnivåklasser.

Vinsten är testbarhet och flexibilitet: du kan ersätta en fejkad databas i tester eller byta betalningsleverantör i produktion genom att ändra koppling, inte affärslogiken.

Form	Hur
Konstruktor	Passerad till konstruktorn (föredraget — obligatoriska beroenden explicita)
Setter	Inställd via en metod efter konstruktion (valfria beroenden)
Gränssnitt/behållare	Ett ramverk löser och injicerar (Spring, .NET DI)