Kaip vykdomas C# kodas (IL, JIT, AOT)?

Question

Accepted Answer

C# nekompiliuojamas tiesiogiai į mašininį kodą. Jis kompiliuojamas į **IL** (Intermediate Language) — platformai nepriklausomą baitą kodą — kurį vykdo **CLR**, naudodamas **JIT** (Just-In-Time) kompiliavimą IL vertimui į natyvų mašininį kodą vykdymo metu. **AOT** (Ahead-Of-Time) yra alternatyva, kuri kompiliuoja į natyvų kodą statybos metu.

## Vykdymo konvejeris

```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# kompiliatorius sukuria **IL** (CPU nepriklausomą baitą kodą), supakuotą surinkinyje. Vykdymo metu **CLR** (Common Language Runtime) naudoja **JIT kompiliatorių** IL metodus versti į natyvų mašininį kodą, kai jie pirmą kartą iškviečiami — ir natyvus kodas saugomas keliems sekliems skambučiams.

## Kodėl IL + JIT? Privalumai

```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 suteikia platformos nepriklausomybę (vienas surinkimas, bet kuri platforma su runtime'u) ir leidžia JIT optimizuoti konkrečią aparatūrą. (Yra pradinis kompiuterio kaštas, kai metodai pirmą kartą JIT-kompiliuojami.)

## AOT — Ahead-Of-Time kompiliavimas

```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** kompiliuoja į natyvų kodą statybos metu — pašalinant JIT pradinio startos kaštu (greitesnis startas, mažiau, mažiau atminties), vertinga serverless ir CLI scenariuose, kuriant lankstumo kaštus.

## Kodėl tai svarbu

Supratimas, kaip vykdomas C# kodas — **IL → JIT → native** konvejeris — yra vertinga žinia norint giliau suprasti .NET platformą, paaiškinti jos galimybes ir priimti apgalvotus sprendimus dėl diegimo ir našumo.

Pagrindinė įžvalga yra ta, kad C# kompiliuojamas į **IL** (platformai nepriklausomą baitą kodą), o ne į natyvų kodą, ir **CLR** naudoja **JIT kompiliavimą** jam vykdymo metu versti į natyvų kodą — tai yra tai, kas įgalina .NET platformos nepriklausomybę (tas pats sukauptas surinkimas veikia bet kurioje vietoje su runtime'u), vykdymo laikmačio optimizavimą (JIT optimizuoja tikrosios aparatūros atžvilgiu) ir kalbos suderinamumą (C#, F#, VB visa kompiliuojasi į IL).

Tai paaiškina tokius elgesius kaip JIT pradinio startos/šildymo kaštas (aktualus benchmarking'o arba pradinio startos optimizavimo metu).

Supratimas **AOT** (Native AOT, šiuolaikinė alternatyva, kompiliuojanti į natyvų kodą statybos metu) yra vis svarbesnis konkretūs scenarijai: jis suteikia **greitesnį startą, mažesnius diegimus ir mažesnę atmintį** (vertinga serverless funkcijoms, CLI įrankiams ir konteineriams, kuriuose startas ir dydis svarbu), to kainos sumažėjus vykdymo laikmačio JIT optimizavimui ir kai kuriems reflection/dinaminėms apribojimams — todėl žinoti JIT-vs-AOT kompromisą padeda pasirinkti tinkamą diegimo tikslo metodą.

Nors tai yra labiau koncepcinis nei kasdienio kodavimo žinios, supratimas apie vykdymo modelį (IL/JIT/AOT) yra vertingas paaiškinti, kaip .NET pasiekia platformos nepriklausomybę ir našumą, ginčytis apie pradinio startos našumą ir priimti diegimo sprendimus (ypač augant AOT svarbai debesies scenariuose) — todėl verta per senjoro lygį žinios, rodančios gilų .NET platformos supratimą ir yra aktualus per našumą ir diegimą sutelktuose diskusiose.