.NET Internals — CLR, CTS, CLS, IL, JIT, Memory Management & Garbage Collection

.NET is a developer platform: a runtime that executes code (the CLR), a huge class library (BCL), languages (C#, VB.NET, F#), SDK tools (dotnet CLI, compilers, NuGet) and app models (ASP.NET, WinForms, WPF, MAUI, Worker Services).

┌──────────────────────────────────────────────────────────────┐
│ Your code: C# · VB.NET · F#                                    │
├──────────────────────────────────────────────────────────────┤
│ App models: ASP.NET Core · Web Forms/MVC (Framework) · WPF ·   │
│             WinForms · MAUI · Worker · Console                 │
├──────────────────────────────────────────────────────────────┤
│ Base Class Library (BCL): System, Collections, IO, Net, Linq,  │
│ Threading, Text.Json, Data, Security …                         │
├──────────────────────────────────────────────────────────────┤
│ CLR (Common Language Runtime): JIT · GC · type system (CTS) ·  │
│ type safety · exceptions · threading · security · interop      │
├──────────────────────────────────────────────────────────────┤
│ Operating system: Windows · Linux · macOS · (Android/iOS)      │
└──────────────────────────────────────────────────────────────┘

Every .NET version (release year, what shipped, support status as of 2026):

.NET Framework (Windows only):

.NET Framework 4.8/4.8.1 is supported as part of Windows (no new features). Web Forms, WCF server and Windows Workflow exist only here.

.NET Core (cross-platform, open source):

.NET 5 and later ("one .NET" — the successor of both Framework and Core):

Support policy: a new version every November; LTS (even numbers) = 3 years of support, STS (odd numbers) = 2 years (extended from 18 months starting with .NET 9). .NET Standard (1.0–2.1) was a specification of APIs shared by Framework, Core, Xamarin and Unity — target netstandard2.0 only for libraries that must still run on .NET Framework.

From source code to running program:

1. Write C#/VB.NET/F# source.
2. Compile — Roslyn (csc/vbc, run by dotnet build/MSBuild) produces an assembly (.dll/.exe) containing IL + metadata (types, members, references) + manifest (assembly name, version, culture, references, resources).
3. Launch — the host (dotnet.exe/apphost/IIS ANCM) reads *.runtimeconfig.json, locates the right runtime version and starts the CLR (coreclr.dll / libcoreclr.so).
4. Load — the assembly loader loads the assembly and its dependencies (*.deps.json) into an AssemblyLoadContext.
5. Type loading — the first use of a type builds its MethodTable (type info, method slots), runs its static constructor.
6. JIT — the first call to a method compiles its IL to native code (tier 0, quick), replaces the stub; hot methods are recompiled with full optimisations (tier 1, possibly using profile data — Dynamic PGO).
7. Execute — native code runs on the CPU; allocations go to the managed heap; the GC reclaims unreachable objects; exceptions unwind stack frames.
8. Shutdown — finalizers may run, the process exits and the OS frees everything.

• Inspect IL/assemblies: ILSpy, dnSpy, dotPeek, ildasm (Framework SDK), SharpLab.io (C# → IL → JIT assembly in the browser).
• Diagnostics CLI: dotnet-counters (GC, CPU, thread pool live), dotnet-trace (event traces), dotnet-dump (memory dumps + analyze), dotnet-gcdump (heap snapshots), dotnet-stack.
• Profilers: Visual Studio Diagnostic Tools / Performance Profiler, PerfView, JetBrains dotMemory/dotTrace, WinDbg + SOS.
• Benchmarking: BenchmarkDotNet ([MemoryDiagnoser] shows allocations).
• Info: dotnet --info, dotnet --list-runtimes, dotnet --list-sdks.