Kako se izvršava C# koda (IL, JIT, AOT)?

Question

Accepted Answer

C# se ne prevaja neposredno v strojni kod. Prevaja se v **IL** (Intermediate Language) — neodvisen od platforme bytecode — katerega izvršava **CLR**, pri čemer uporablja **JIT** (Just-In-Time) prevajanje za prevajanje IL v nativni strojni kod med izvajanjem. **AOT** (Ahead-Of-Time) je alternativa, ki prevaja v nativni kod ob času gradnje.

## Cevovod izvršavanja

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

C# prevajalnik proizvede **IL** (bytecode neodvisen od CPU), pakiran v sestav. Med izvajanjem **CLR** (Common Language Runtime) uporablja **JIT prevajalnik** za prevajanje IL metod v nativni strojni kod, ko so prvič poklicane — in nativni kod je predpomnjen za naslednje klice.

## Zakaj IL + JIT? Prednosti

```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 daje neodvisnost od platforme (en sestav, katero koli platformo s časovno zmogljivostjo) in omogoča JIT-u optimiziranje za specifično strojno opremo. (Obstaja stroški zagona, ko se metode JIT-kompajlirajo ob prvi uporabi.)

## AOT — Prevajanje vnaprej

```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** prevaja v nativni kod ob času gradnje — odpravi stroške zagona JIT (hitrejši zagon, manjši, manj pomnilnika), dragocen za brezstrežniške in CLI aplikacije, na račun nekaj fleksibilnosti.

## Zakaj je to pomembno

Razumevanje, kako se C# koda izvršava — cevovod **IL → JIT → nativno** — je dragoceno znanje za globlje razumevanje platforme .NET, razlago njenih zmožnosti in sprejemanje informirane odločitve o distribuciji in zmogljivosti.

Osrednja ugotovitev je, da se C# prevaja v **IL** (neodvisen od platforme bytecode) namesto v nativni kod, in **CLR** uporablja **JIT prevajanje** za prevajanje v nativni kod med izvajanjem — kar omogoči neodvisnost .NET od platforme (isti prevajani sestav teče povsod, kjer je dostopna časovna zmogljivost), optimizacijo med izvajanjem (JIT optimizira za dejansko strojno opremo) in med-jezikovne interoperabilnosti (C#, F#, VB se vsi prevajajo v IL).

To pojasnjuje vedenja, kot so stroški in ogrevanje JIT zagona (relevantno pri primerjanju učinkovitosti ali optimizaciji zagona).

Razumevanje **AOT** (Native AOT, sodobna alternativa, ki se prevaja v nativni kod ob času gradnje) je vedno bolj pomembno za specifične scenarije: zagotavlja **hitrejši zagon, manjše razvrstitve in nižjo porabo pomnilnika** (dragoceno za funkcije brez strežnika, CLI orodja in posode, kjer sta čas zagona in velikost pomembna), na račun JIT optimizacije med izvajanjem in nekaterih omejitev odboja/dinamike — zato je poznavanje boja JIT-vs-AOT vam pomaga pri izbiri pravega pristopa za cilj distribucije.

Čeprav je to bolj konceptualno kot znanje vsakodnevnega kodiranja, je razumevanje modela izvršavanja (IL/JIT/AOT) dragoceno za razlago, kako .NET dosega neodvisnost od platforme in zmogljivosti, za razmišljanje o zmogljivosti zagona in za sprejemanje odločitev o distribuciji (zlasti rastoča pomembnost AOT za scenarije v oblaku) — kar ga naredi vrednega znanja višje ravni, ki kaže globoko razumevanje platforme .NET in je relevantna tema za razprave osredotočene na zmogljivost in razporeditev.