Jak se spouští kód v C# (IL, JIT, AOT)?

Question

Accepted Answer

C# se nekompiluje přímo na strojový kód. Kompiluje se na **IL** (Intermediate Language) — platformně nezávislý bytecode — který spouští **CLR** pomocí **JIT** (Just-In-Time) kompilace, která při běhu překládá IL na nativní strojový kód. **AOT** (Ahead-Of-Time) je alternativa, která se kompiluje na nativní kód v čase buildu.

## Spouštěcí pipeline

```text
C# source (.cs)
   │  C# compiler (roslyn)
   ▼
IL bytecode (in a .dll/.exe assembly)  ← platform-INDEPENDENT intermediate code
   │  CLR loads it; JIT compiles IL → native code AT RUNTIME (per method, as called)
   ▼
Native machine code → executes on the CPU
```

Kompiler C# vytváří **IL** (CPU-nezávislý bytecode), zabalený v assembly. Za běhu používá **CLR** (Common Language Runtime) **JIT kompilátor** k překladu IL metod na nativní strojový kód při jejich prvním zavolání — a nativní kód se cachuje pro následující volání.

## Proč IL + JIT? Výhody

```text
✓ Platform independence — the SAME IL runs on any platform with a CLR
✓ Runtime optimization — the JIT optimizes for the ACTUAL hardware it runs on
✓ Language interoperability — C#, F#, VB all compile to IL → can interoperate
✓ The CLR provides GC, type safety, security on top
```

IL + JIT poskytuje platformní nezávislost (jedna assembly, jakákoliv platforma s runtime) a umožňuje JIT optimalizovat pro specifický hardware. (Existuje startup cost, když se metody poprvé JIT-kompilují.)

## AOT — Ahead-Of-Time kompilace

```text
Native AOT (modern .NET) → compiles directly to native machine code at BUILD time.
  ✓ FASTER startup (no JIT at runtime), smaller deployment, lower memory
  ✓ Good for: serverless, CLI tools, containers (where fast startup matters)
  ✗ Trade-offs: no runtime JIT optimization, some reflection/dynamic limitations
JIT (default) → flexible, runtime-optimized, but has startup/warm-up cost.
```

**AOT** se kompiluje na nativní kód v čase buildu — eliminuje JIT startup cost (rychlejší start, menší, méně paměti), cenné pro serverless a CLI, za cenu určité flexibility.

## Proč na tom záleží

Pochopení toho, jak se kód v C# spouští — pipeline **IL → JIT → native** — je cenné pro hluboké porozumění platformě .NET, vysvětlení jejích schopností a přijímání informovaných rozhodnutí o nasazení a výkonu.

Klíčová myšlenka spočívá v tom, že se C# kompiluje na **IL** (platformně nezávislý bytecode) spíše než na nativní kód, a **CLR** používá **JIT kompilaci** k překladu na nativní kód za běhu — což je to, co umožňuje .NET platformní nezávislost (stejná zkompilovaná assembly se spouští kdekoli s runtime), runtime optimalizaci (JIT optimalizuje pro skutečný hardware) a interoperabilitu jazyků (C#, F#, VB se všechny kompilují na IL).

To vysvětluje chování, jako je JIT startup/warm-up cost (relevantní při benchmarkování nebo optimalizaci startu).

Pochopení **AOT** (Native AOT, moderní alternativa kompilující se na nativní kód v čase buildu) je čím dál tím důležitější pro konkrétní scénáře: poskytuje **rychlejší start, menší nasazení a nižší paměť** (cenné pro serverless funkce, CLI nástroje a kontejnery, kde na počtu start a velikosti záleží), za cenu runtime JIT optimalizace a některých omezení reflexe/dynamiky — takže znalost trade-offu JIT vs AOT vám pomůže vybrat správný přístup pro cíl nasazení.

I když je to spíše koncepční než každodenní znalost kódování, pochopení modelu spouštění (IL/JIT/AOT) je cenné pro vysvětlení toho, jak .NET dosahuje platformní nezávislosti a výkonu, pro uvažování o výkonu startu a pro přijímání rozhodnutí o nasazení (zejména rostoucí relevance AOT pro cloud-native scénáře) — čímž se stává hodnotnou znalostí na seniorní úrovni, která demonstruje hluboké porozumění platformě .NET a je relevantním tématem pro diskuse zaměřené na výkon a nasazení.