1. What happens when you compile a C# program?
When you compile C#, the Roslyn compiler translates your source code into CIL (Common Intermediate Language) and stores it in a .NET assembly with metadata. At runtime, the CLR loads this IL and compiles it to native machine code using the Just-In-Time (JIT) compiler.
2. What is the CLR in .NET?
The Common Language Runtime (CLR) is the virtual machine that executes C# code. It manages memory, type safety, exceptions, garbage collection, and JIT compilation, making .NET code platform-independent and secure.
3. What is the role of IL (Intermediate Language)?
IL is a CPU-independent instruction set produced from C# code. The CLR later converts IL into native instructions. This intermediate stage allows .NET to support multiple languages and platforms through the same runtime.
4. How does the JIT compiler work?
The JIT (Just-In-Time) compiler translates IL into native machine code on demand—typically the first time a method is called. It then caches that machine code for reuse, optimizing execution speed.
5. What are assemblies in .NET?
Assemblies are compiled units of code (DLLs or EXEs) that contain IL, metadata, and resources. They’re the fundamental deployment unit in .NET, providing versioning and type information for the CLR.
6. What is metadata in .NET assemblies?
Metadata is embedded information that describes every type, member, and attribute in your code. It enables reflection, type safety, and dynamic loading at runtime.
7. What is the difference between a DLL and EXE in .NET?
Both are assemblies, but an EXE has an entry point (Main method) and can run directly, whereas a DLL is a reusable library intended to be called by other applications.
8. How does the .NET runtime handle type safety?
The CLR verifies that all IL instructions follow strict typing rules before execution. This prevents invalid memory access and enforces strong type boundaries between objects.
9. What is managed code?
Managed code runs under the control of the CLR, which handles memory allocation, exception handling, and garbage collection automatically.
10. What is unmanaged code?
Unmanaged code executes directly on the OS without CLR supervision, typically written in C/C++. It can be accessed via P/Invoke or COM interop.
JIT Compilation & Performance
11. What are the types of JIT compilation?
There are three:
- Pre-JIT (AOT): Entire assembly compiled at install time.
- Econo-JIT: Compiles methods as needed, then discards them.
- Normal JIT: Compiles methods when first called and caches them.
12. What is ReadyToRun (R2R) in .NET?
ReadyToRun is a precompiled native image format that speeds up startup by avoiding JIT compilation for most methods while still allowing runtime optimizations.
13. What is tiered compilation?
Tiered compilation allows .NET to JIT compile methods first with minimal optimizations, then recompile hot paths with aggressive optimizations for better performance.
14. What is NGen?
Native Image Generator (NGen) precompiles IL into native binaries stored in the assembly cache, reducing JIT time but reducing flexibility for dynamic optimization.
15. How does the JIT optimizer improve code?
The JIT performs constant folding, loop unrolling, inlining, and dead code elimination to optimize runtime performance dynamically based on the execution environment.
Garbage Collection (GC)
16. What is garbage collection in .NET?
The GC automatically reclaims memory occupied by unreachable objects. It runs in generations to minimize pauses and manage memory efficiently.
17. What are GC generations?
Objects are grouped into Generation 0, 1, and 2. Short-lived objects are collected frequently (Gen 0), while long-lived ones move to higher generations for less frequent collection.
18. What is the Large Object Heap (LOH)?
The LOH stores large objects (over 85 KB). These are expensive to allocate and compact, so they are collected less often.
19. What is a GC root?
A GC root is any reference that prevents an object from being collected — such as static variables, stack references, or CPU registers holding managed pointers.
20. What triggers garbage collection?
A collection occurs when memory pressure increases, Gen 0 fills up, or GC.Collect() is called explicitly (which is usually discouraged).
Memory & Execution
21. How does .NET manage memory?
The CLR allocates objects on the managed heap and handles deallocation through garbage collection, ensuring memory safety without manual freeing.
22. What is the difference between stack and heap?
The stack stores value types and call frames, while the heap stores reference types. Stack allocation is faster but limited in scope.
23. What is boxing and unboxing?
Boxing converts a value type to an object (placing it on the heap). Unboxing extracts it back to a value type. Excessive boxing can hurt performance.
24. How does .NET handle threads?
Threads are managed via the ThreadPool and Task Parallel Library, allowing efficient concurrency through work-stealing and async scheduling.
25. What is async/await in C#?
Async/await allows asynchronous operations to execute without blocking threads by pausing execution until awaited tasks complete.
Assemblies & Metadata
26. What are strong-named assemblies?
They have a cryptographic signature that uniquely identifies the version and origin of the assembly, preventing tampering or substitution.
27. What is the GAC?
The Global Assembly Cache stores shared assemblies used by multiple applications, identified by strong names.
28. What is reflection in .NET?
Reflection lets you inspect metadata, types, and members at runtime and dynamically create or invoke objects.
29. What is the difference between Assembly.Load and Assembly.LoadFrom?
Load loads from the GAC or already loaded assemblies, while LoadFrom can load directly from a file path outside standard probing paths.
30. How does .NET resolve assembly references?
The CLR searches in this order: application directory, GAC, configuration-defined paths, and custom AssemblyResolve events.
C# Internals
31. How are value types stored internally?
Value types are stored inline, either on the stack or inside containing objects, not as heap references.
32. How are reference types represented?
Reference types are pointers to objects on the heap, with a header containing sync blocks and type metadata.
33. How are strings stored in .NET?
Strings are immutable UTF-16 sequences stored on the heap. They’re interned by the runtime to reuse identical instances.
34. How does the CLR manage exceptions?
When an exception is thrown, the CLR unwinds the call stack to find a matching catch block, cleaning up local variables automatically.
35. How does C# handle delegates internally?
Delegates are objects containing method pointers and optional target references, providing type-safe function callbacks.
Advanced Runtime Features
36. What is the difference between struct and class internally?
Structs are value types allocated inline without reference overhead; classes are reference types allocated on the heap and accessed by pointers.
37. What is a type handle?
A type handle is an internal CLR structure that points to a type’s runtime method table, used for quick type lookups.
38. What is a method table?
Each reference type has a method table storing metadata about its methods, virtual table entries, and inheritance information.
39. How does .NET implement virtual methods?
Virtual calls are resolved via a vtable pointer in the object’s method table, enabling polymorphism at runtime.
40. What is interface dispatch?
Interface calls use an indirection layer to find the correct implementation method pointer at runtime.
Security & Interop
41. How does the CLR enforce security?
The CLR enforces security through code access security (CAS), sandboxing, and runtime verification of IL.
42. What is P/Invoke?
Platform Invocation Services allow managed code to call native functions in DLLs using attributes like [DllImport].
43. What is COM interop?
COM interop enables managed and unmanaged code to communicate using Runtime Callable Wrappers (RCWs).
44. What are unsafe blocks?
Unsafe blocks allow pointer manipulation in C#, bypassing CLR safety checks. They’re used for high-performance or interop code.
45. How does .NET prevent buffer overflows?
By enforcing type safety, array bounds checking, and memory isolation, buffer overflows are virtually impossible in managed code.
Runtime Execution Model
46. What is the lifecycle of a .NET application?
Compilation → IL generation → CLR load → JIT compilation → Execution → Garbage collection → Process termination.
47. What is AppDomain?
AppDomains were used to isolate managed applications within a process. .NET Core replaces this with process-level isolation.
48. How does the CLR load types?
The CLR reads metadata tables to construct Type objects and links IL method bodies lazily on demand.
49. What is late binding?
Late binding resolves method calls at runtime using reflection or dynamic typing, allowing flexible behavior but slower execution.
50. What is early binding?
Early binding resolves method calls at compile time, ensuring type safety and faster execution.
Threads, Tasks & Asynchronous Execution
51. What is the ThreadPool in .NET?
The ThreadPool is a shared pool of background threads managed by the CLR. It optimizes thread reuse, reduces creation overhead, and automatically scales the number of active threads based on workload.
52. How are async methods executed internally?
Async methods compile into state machines. The compiler transforms your code into a structure that uses Task and await to schedule continuations, resuming execution after awaited operations complete.
53. What is the difference between Task and Thread?
A Thread represents a physical OS thread. A Task is a higher-level abstraction managed by the Task Parallel Library (TPL) that can run on the ThreadPool and coordinate async work efficiently.
54. How does the Task Scheduler work?
The Task Scheduler determines which threads execute tasks. The default scheduler uses the ThreadPool but can be customized for specific concurrency models.
55. What is SynchronizationContext in C#?
It defines how asynchronous operations resume after completion. For example, UI apps use SynchronizationContext to marshal code back to the main thread.
56. What are continuations in async programming?
Continuations are the code segments that execute after a Task finishes. They’re automatically managed by the compiler via await.
57. What is deadlock in C#?
A deadlock occurs when threads wait on each other’s resources indefinitely. This often happens when blocking async code with .Result or Wait().
58. What is a race condition?
A race condition occurs when multiple threads access shared data simultaneously and at least one modifies it, causing unpredictable behavior.
59. How does C# prevent race conditions?
C# provides synchronization primitives like lock, Monitor, Mutex, and Semaphore to ensure thread-safe access to shared data.
60. What is the difference between lock and Monitor?
lock is syntactic sugar for Monitor.Enter and Monitor.Exit, automatically handling exceptions and releases. Both are used for critical sections.
Memory Management & Internals
61. What is the managed heap?
The managed heap is a memory area controlled by the CLR that stores reference-type objects. The GC manages allocation and compaction automatically.
62. What is the ephemeral segment?
The ephemeral segment of the heap stores short-lived objects from Generations 0 and 1, enabling faster collection cycles.
63. How does .NET compact memory?
After collection, the GC can compact the heap by moving live objects together and updating references, reducing fragmentation.
64. What are pinned objects?
Pinned objects have fixed memory addresses that the GC can’t move. They’re used in interop scenarios but can cause heap fragmentation.
65. What is memory pressure?
Memory pressure indicates unmanaged memory usage that may trigger earlier GC cycles. Developers can report it using GC.AddMemoryPressure().
66. How does .NET handle finalization?
Objects with finalizers are placed in a special queue and collected in two passes: first marked, then finalized, delaying cleanup until safe.
67. What is IDisposable used for?
The IDisposable interface defines a Dispose() method to free unmanaged resources deterministically without waiting for GC.
68. What is using() in C#?
using() ensures that objects implementing IDisposable are automatically disposed when leaving the scope, even if exceptions occur.
69. What is a memory leak in .NET?
Memory leaks occur when objects remain referenced unintentionally, preventing GC from collecting them, even though they’re no longer needed.
70. How to detect memory leaks in .NET?
You can use diagnostic tools like dotMemory, PerfView, or Visual Studio Profiler to inspect heap snapshots and track retained objects.
Execution Model & CLR Features
71. What is the Common Type System (CTS)?
CTS defines how data types are declared, used, and managed across all .NET languages, ensuring type compatibility and consistent runtime behavior.
72. What is the Common Language Specification (CLS)?
CLS is a subset of CTS defining rules that ensure interoperability between all .NET languages, like C#, VB.NET, and F#.
73. What is the purpose of the Base Class Library (BCL)?
The BCL provides the fundamental types (e.g., System.Object, System.String, System.IO) used by all .NET applications.
74. How are exceptions propagated internally?
When an exception occurs, the CLR walks up the call stack, searching for a catch block. If none exists, it terminates the thread or process.
75. What is stack unwinding?
Stack unwinding happens when an exception is thrown, and the runtime pops stack frames, calling destructors or finally blocks as it goes.
76. What is reflection emit?
Reflection emit allows dynamic creation of types and methods at runtime by generating IL programmatically.
77. What is dynamic code generation?
Dynamic code generation lets you produce executable code during runtime using APIs like System.Reflection.Emit or expression trees.
78. What is cross-language interoperability?
Because all .NET languages compile to IL, types created in one language can be used seamlessly in another.
79. What are attributes in .NET?
Attributes are metadata annotations added to assemblies, classes, or members that influence runtime or tooling behavior.
80. How does .NET resolve metadata?
The CLR loads metadata tables from assemblies at runtime and builds runtime type structures in memory to represent types, methods, and fields.
Runtime Performance & Optimization
81. What are value-type optimizations?
The JIT often inlines structs and passes them by reference internally to reduce copying overhead.
82. What is method inlining?
Inlining replaces a method call with its body to avoid the overhead of invoking small methods at runtime.
83. How does the .NET JIT handle generic methods?
The JIT generates a single version of a generic method for all reference types but separate versions for each unique value type.
84. What are tiered optimizations?
Tiered compilation allows methods to be recompiled at runtime with higher optimization levels after being executed frequently.
85. What is profile-guided optimization (PGO)?
PGO collects runtime data about method usage and applies optimizations based on actual execution patterns to improve performance.
86. What is SIMD in .NET?
SIMD (Single Instruction Multiple Data) allows vectorized operations using hardware acceleration via System.Numerics.Vector or HWIntrinsic.
87. What are Span<T> and Memory<T>?
Span<T> and Memory<T> are stack-safe, bounds-checked types that provide fast access to contiguous memory without allocations.
88. How does .NET reduce allocations?
Techniques include using value types, object pooling, caching, ArrayPool<T>, and stack-based data structures like Span<T>.
89. What is the difference between compile-time and runtime constants?
Compile-time constants (const) are embedded in IL, while runtime constants (readonly) are evaluated during construction.
90. How are enums represented internally?
Enums are value types backed by an integral type (default int) with named constants for readability.
Advanced Runtime Concepts
91. What is the difference between reflection and dynamic types?
Reflection inspects types at runtime; dynamic typing allows late-bound operations resolved at runtime using the DLR (Dynamic Language Runtime).
92. How does the Dynamic Language Runtime work?
The DLR adds dynamic features to C#, enabling runtime binding, expression trees, and interoperability with dynamic languages like Python or JavaScript.
93. What is AssemblyLoadContext in .NET Core?
AssemblyLoadContext isolates assemblies, allowing plugin models and unloading without restarting the application.
94. What is NativeAOT?
NativeAOT compiles .NET assemblies directly into native binaries ahead-of-time, improving startup speed and eliminating JIT entirely.
95. What is the role of the metadata tables in CLR?
Metadata tables define all types, methods, fields, and references in an assembly. The CLR reads them to construct runtime type objects and enforce rules.
96. How does .NET manage security transparency?
Security transparency categorizes code into transparent, safe-critical, and critical, determining which operations require elevated trust.
97. How does .NET handle time and globalization?
The System.Globalization and System.TimeZoneInfo classes handle culture-specific formatting and time zone conversions consistently across platforms.
98. What is the difference between portable and non-portable PDBs?
Portable PDBs are cross-platform debugging symbol files used by .NET Core, while traditional PDBs are Windows-specific.
99. What happens during application domain unloading?
In .NET Framework, unloading an AppDomain releases all loaded assemblies, threads, and static references. .NET Core uses assembly unload contexts instead.
100. What makes .NET Core cross-platform?
.NET Core uses platform abstraction layers, runtime-agnostic IL, and OS-specific runtime hosts to run on Windows, Linux, and macOS seamlessly.