What is dependency injection and inversion of control?

Question

Accepted Answer

**Dependency Injection (DI)** means an object receives its dependencies from the outside instead of creating them itself. It's a form of **Inversion of Control (IoC)**: the responsibility for wiring objects is *inverted* away from the object and given to a caller or container.

## Without DI vs. with 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
```

The class now depends on the *abstraction* `OrderRepo`, and someone else decides which concrete one to supply.

## Forms of injection

| Form | How |
|---|---|
| Constructor | Passed to the constructor (preferred — required deps explicit) |
| Setter | Set via a method after construction (optional deps) |
| Interface/container | A framework resolves and injects (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
```

## Why it matters

DI is the practical realization of the Dependency Inversion Principle — high-level logic stops depending on concrete, low-level classes.

The payoff is testability and flexibility: you can substitute a fake database in tests or swap a payment provider in production by changing wiring, not the business logic.

Form	How
Constructor	Passed to the constructor (preferred — required deps explicit)
Setter	Set via a method after construction (optional deps)
Interface/container	A framework resolves and injects (Spring, .NET DI)