377 questions for senior .NET engineer interviews, each with a 30-second answer, the full answer, a deep dive, the follow-ups interviewers ask next, and real-world production problems.
CISC versus RISC design, instruction sets, memory ordering models and SIMD differences between x64 and Arm64, and the practical checklist for .NET: RIDs, native dependencies, multi-arch container images, concurrency correctness, performance testing and cost.
Single instruction, multiple data: vector registers and instruction sets (SSE, AVX2, AVX-512, NEON), the .NET hardware-intrinsic APIs, vectorised BCL methods and TensorPrimitives, writing a vectorised loop with a scalar tail, and when SIMD is or isn't worth it.
How the call stack and the managed heap work, what goes in each (locals, frames, objects, boxed values, captured variables, async state), why "value types live on the stack" is a myth, and the performance and lifetime consequences.
The spectrum from safe object references to managed pointers (ref, in, out, ref locals and ref returns, ref fields in ref structs) to unmanaged pointers in unsafe code, how the GC tracks and moves them, pinning, and when each is appropriate.
The levels of the memory hierarchy with realistic sizes and latencies, why caches exist, how cache lines and associativity work, what is private versus shared between cores, TLBs, and how the hierarchy shapes the performance of everyday .NET code.
Types of cache misses (compulsory, capacity, conflict, coherence) and TLB misses, the symptoms of memory-bound code, how to measure misses on Windows and Linux for .NET processes, and the design changes that reduce them.
Natural alignment, padding and why misaligned access is slow or non-atomic, how the CLR lays out classes (auto) and structs (sequential by default, auto when they contain references), object headers and minimum object size, measuring sizes, and using StructLayout, FieldOffset, Pack and InlineArray for interop and performance.
How the call stack overflows, why .NET terminates the process instead of letting you catch it, common causes (unbounded or deep recursion, self-referencing properties, cyclic object graphs, large stackalloc), and how to diagnose with crash output, dumps and tests.
Process memory from the operating system's and the runtime's point of view: physical RAM versus virtual address space, working set, private and committed memory, the GC heap and native memory, container cgroup limits, GC heap hard limits, Server GC and DATAS, and a step-by-step investigation of OOMKilled pods.
How allocation works on the managed heap (bump-pointer allocation in per-thread contexts), how generations and promotion keep collections cheap, when objects go to the large object heap, why pinning matters and the pinned object heap, and how to measure and reduce allocations.
The kernel's responsibilities, CPU privilege levels (rings on x64, exception levels on Arm64), why applications run in user mode, how and when the CPU switches to kernel mode, and what that means for .NET applications, drivers, containers and security.
The system call mechanism, the path from .NET APIs through SafeHandles and the PAL to Windows (IOCP) and Linux (epoll) interfaces, the cost of crossing into the kernel, and how buffering, batching and async I/O reduce that cost. Includes tracing system calls with strace and Process Monitor.
What a process owns (address space, handles, security context) versus what a thread owns (stack, registers, thread-local storage), how threads share memory, how .NET threads map to OS threads, how the thread pool and Task build on them, and when to use multiple processes instead of threads.
Preemptive scheduling, run queues, time slices, priorities and starvation, how Windows and Linux schedulers differ at a high level, CPU affinity and NUMA, and how cgroup CPU quotas throttle containers and interact with the .NET thread pool and GC.
What the OS saves and restores on a context switch, thread versus process switches, direct and indirect costs (cache and TLB pollution), voluntary versus involuntary switches, how blocking code and oversized thread counts multiply them, and how to measure and reduce them.
Why virtual memory exists, pages and page frames, multi-level page tables, the TLB, demand paging, copy-on-write, memory-mapped files, swap and the page file, overcommit, address space layout randomisation, and what all this means for .NET processes.
Page faults, minor vs major faults, what triggers them, and how to diagnose paging-related latency in a .NET service.
File descriptors and handles as the OS's per-process references to kernel resources, their limits, and how .NET wraps them with SafeHandle and IDisposable.
Diagnosing descriptor exhaustion and socket exhaustion in .NET on Linux: ulimit, lsof, ss, TIME_WAIT, ephemeral ports, and the HttpClient/IHttpClientFactory fixes.
Files, directories, metadata, inodes and links, plus efficient directory enumeration in .NET with EnumerateFiles and EnumerationOptions.