C# kodu nasıl yürütülür (IL, JIT, AOT)?

Question

Accepted Answer

C# doğrudan makine koduna derlenmez. **IL** (Ara Dil) — platformdan bağımsız bytecode — olarak derlenir ve **CLR** bunu çalıştırır, IL'i çalışma zamanında yerel makine koduna çevirmek için **JIT** (Just-In-Time) derlemesini kullanır. **AOT** (Ahead-Of-Time), derleme zamanında yerel koda derleyen bir alternatiftir.

## Yürütme ardışık düzeni

```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# derleyicisi **IL** (CPU'dan bağımsız bytecode) üretir ve bunu bir assembly içinde paketler. Çalışma zamanında, **CLR** (Common Language Runtime), IL metotlarını ilk çağrıldıklarında yerel makine koduna çevirmek için **JIT derleyicisini** kullanır — ve yerel kod sonraki çağrılar için önbelleğe alınır.

## Neden IL + JIT? Avantajları

```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, platformdan bağımsızlık (bir assembly, çalışma zamanı olan herhangi bir platform) ve JIT'in belirli donanım için optimize etmesini sağlar. (Metotlar ilk kullanımda JIT-derlendiğinde başlangıç maliyeti vardır.)

## AOT — Ahead-Of-Time derlemesi

```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**, derleme zamanında yerel koda derler — JIT başlangıç maliyetini ortadan kaldırır (daha hızlı başlangıç, daha küçük, daha az bellek), sunucusuz ve CLI'lar için değerlidir, esnekliğin bir kısmı pahasına.

## Neden önemli

C# kodunun nasıl yürütüldüğünü anlamak — **IL → JIT → native** ardışık düzeni — .NET platformunu derinlemesine anlamak, yeteneklerini açıklamak ve dağıtım ile performans hakkında bilinçli kararlar almak için değerli bir bilgidir.

Ana fikir, C#'ın yerel koda değil **IL** (platformdan bağımsız bytecode) olarak derlendiği ve **CLR**'nin bunu çalışma zamanında yerel koda çevirmek için **JIT derlemesini** kullandığıdır — bu .NET'in platformdan bağımsızlığını (aynı derlenmiş assembly, çalışma zamanı olan herhangi bir yerde çalışır), çalışma zamanı optimizasyonunu (JIT gerçek donanım için optimize eder) ve dil birlikte çalışabilirliğini (C#, F#, VB hepsi IL'e derler) mümkün kılar.

Bu, JIT başlangıç/ısınma maliyeti gibi davranışları açıklar (kıyaslama yaparken veya başlangıcı optimize ederken uygun).

**AOT** (Native AOT, derleme zamanında yerel koda derleyen modern bir alternatif) anlama, belirli senaryolar için giderek önemli hale gelmektedir: **daha hızlı başlangıç, daha küçük dağıtımlar ve daha düşük bellek** sağlar (sunucusuz işlevler, CLI araçları ve başlangıç zamanı ile boyutun önemli olduğu kapsayıcılar için değerlidir), çalışma zamanı JIT optimizasyonu ve bazı reflection/dinamik sınırlamalarının pahasına — bu nedenle JIT-vs-AOT dengesi bilmek dağıtım hedefi için doğru yaklaşımı seçmenize yardımcı olur.

Bu, günlük kodlamadan daha kavramsal olsa da, yürütme modelini (IL/JIT/AOT) anlamak .NET'in platformdan bağımsızlığı ve performansı nasıl elde ettiğini açıklamak, başlangıç performansını hakkında akıl yürütmek ve dağıtım kararları almak için değerlidir (özellikle bulut-native senaryoları için AOT'ın artan alaka düzeyi) — bunu .NET platformunun derinlemesine anlaşılmasını gösteren ve performans ile dağıtıma odaklanmış tartışmalar için uygun bir konu olan yararlı üst düzey bilgi haline getirir.