Was ist Design by Contract?

Question

Accepted Answer

**Design by Contract (DbC)** behandelt die Beziehung zwischen einer method und ihrem Aufrufer als formale Vereinbarung, definiert durch drei Dinge: **preconditions** (was der Aufrufer garantieren muss), **postconditions** (was die method dafür garantiert), und **invariants** (was für das object jederzeit wahr bleibt).

## Die drei Verpflichtungen

```text
PRECONDITION  → caller's duty: inputs/state the method requires to run correctly
POSTCONDITION → method's duty: what it promises on return (if precondition held)
INVARIANT     → always-true property of the object, before and after every method
```

## Im Code

```python
class Account:
    def __init__(self, balance):
        self._balance = balance
        self._check_invariant()

def withdraw(self, amount):
        assert amount > 0, "PRE: amount must be positive"        # precondition
        assert amount <= self._balance, "PRE: sufficient funds"  # precondition
        old = self._balance
        self._balance -= amount
        assert self._balance == old - amount, "POST: balance reduced"  # postcond
        self._check_invariant()

def _check_invariant(self):
        assert self._balance >= 0, "INVARIANT: balance never negative"
```

Wenn eine *precondition* fehlschlägt, hat der **Aufrufer** den Fehler. Wenn eine *postcondition* oder *invariant* fehlschlägt, hat die **method** den Fehler — Contracts zeigen die Schuld genau auf.

## Beziehung zu LSP

DbC macht Liskov präzise: Ein Subtyp darf **preconditions abschwächen** und **postconditions verstärken**, aber niemals umgekehrt. Das ist genau die Substitutionsregel, ausgedrückt als Contracts.

## Warum es wichtig ist

Contracts wandeln vage Annahmen ("der Betrag sollte positiv sein, glaube ich") in explizite, überprüfbare Regeln um — und sie weisen die Schuld präzise zu, wenn etwas kaputtgeht.

Sie unterstützen Liskov-Substitution und robustes API-Design: Der Contract einer method ist seine wahre Schnittstelle, ehrlicher als nur seine type signature.

## Trade-offs

```text
✓ Bugs surface at the boundary, with clear blame   ✓ Contracts double as documentation
⚠️ Runtime checks cost performance (often disabled in prod via assertions)
⚠️ Not all languages enforce it natively (Eiffel does; most use asserts/validation)
```