CLR & Runtime

// C# source compiles to IL, which the CLR JIT-compiles to native code at runtime
public int Add(int a, int b) => a + b;
// Compiled IL (simplified): ldarg.1, ldarg.2, add, ret

Common follow-ups: What's the difference between IL and native machine code?;How does the CLR differ from the JVM conceptually?

// JIT: method compiled to native code the first time it's called
public void ProcessOrder() { ... }  // IL until first invocation, then JIT-compiled

// Native AOT: entire app compiled to native code at publish time
dotnet publish -p:PublishAot=true

Common follow-ups: What is tiered compilation and how does it balance JIT startup cost against optimization?;Why can't Native AOT support all the same runtime reflection scenarios as JIT?

<PropertyGroup>
  <TieredCompilation>true</TieredCompilation>  <!-- default: true -->
  <TieredPGO>true</TieredPGO>  <!-- dynamic profile-guided optimization, default: true in modern .NET -->
</PropertyGroup>

Common follow-ups: What is Dynamic PGO and how does it use runtime profiling data?;Can you disable tiered compilation for latency-sensitive scenarios where consistent performance matters more than average throughput?

struct Point { public int X, Y; }  // value type, typically stack-allocated
class Person { public string Name; }  // reference type, heap-allocated

Point p1 = new Point { X = 1, Y = 2 };
Point p2 = p1;  // COPY -- p2 is independent of p1

Person person1 = new Person { Name = "Alice" };
Person person2 = person1;  // REFERENCE -- both point to the same object

Common follow-ups: When does a struct actually get boxed onto the heap despite being a value type?;What's the performance trade-off of large structs being copied by value?

int number = 42;
object boxed = number;       // boxing: heap allocation occurs
int unboxed = (int)boxed;    // unboxing: type check + copy

// Generics avoid boxing entirely:
List<int> numbers = new();   // no boxing when adding ints
numbers.Add(42);

Common follow-ups: How would you detect excessive boxing in a running application?;Why do generic collections avoid boxing while non-generic ones don't?

// C# class
public class Point { public int X { get; set; } }

// F# can consume it directly since both compile to compatible CTS-conforming IL
let p = Point(X = 5)

Common follow-ups: What's the difference between the CTS and the Common Language Specification (CLS)?;Why can't all CTS features be expressed in every .NET language equally?

// Expensive: using exceptions for expected, frequent control flow
try { return int.Parse(userInput); }
catch (FormatException) { return 0; }  // exception thrown on every invalid input

// Better: TryParse avoids exception overhead entirely
return int.TryParse(userInput, out var result) ? result : 0;

Common follow-ups: Why is stack unwinding specifically the expensive part of exception handling?;What's the actual measured overhead difference between TryParse and catching a FormatException?

// BCL types used constantly, running on top of the CLR
List<string> names = new();
StreamReader reader = new StreamReader("file.txt");
var result = names.Where(n => n.StartsWith("A")).ToList();  // LINQ, part of BCL

Common follow-ups: What parts of the BCL are implemented in C# versus lower-level languages?;How do you distinguish a CLR-level feature from a BCL-level API in documentation?

// The CLR prevents this class of bug entirely (unlike C/C++):
int[] array = new int[5];
// array[10] = 1;  // throws IndexOutOfRangeException, not silent memory corruption

// Type safety enforced at the IL level:
object obj = "hello";
// int x = (int)obj;  // throws InvalidCastException, not undefined behavior

Common follow-ups: What unmanaged resource leaks can still occur despite the CLR's memory safety?;How does `unsafe` code in C# opt out of some of these guarantees?

unsafe {
    fixed (byte* ptr = buffer) {
        for (int i = 0; i < buffer.Length; i++) {
            *(ptr + i) = 0;  // direct pointer manipulation, bypasses bounds checking
        }
    }
}
// Requires <AllowUnsafeBlocks>true</AllowUnsafeBlocks> in the .csproj

Common follow-ups: How does Span<T> provide similar performance benefits without needing unsafe code?;What are the risks of unsafe code re-introducing memory corruption bugs?