Expert C# Interview Questions

The CLR is the execution engine for .NET applications. It manages memory, performs JIT compilation, enforces type safety, handles exceptions, and manages garbage collection.

It abstracts low-level memory management and provides a secure, consistent runtime environment, enabling cross-language interoperability and automatic memory management.

The JIT compiler converts IL to machine code just before execution. It applies hardware-specific optimizations such as inlining, dead-code elimination, and CPU-tuned instruction generation.

It may recompile methods dynamically based on runtime execution patterns, making performance adaptive.

C# enforces strict type-checking, prevents unsafe casts, limits pointer operations, and ensures invalid operations are caught at compile time or enforced by the CLR.

This eliminates memory corruption, improves security, and reduces runtime crashes.

Managed resources are controlled by the CLR (objects, arrays, strings), while unmanaged resources (file handles, sockets, DB connections) must be released manually via IDisposable.

Failure to release unmanaged resources leads to leaks and OS-level exhaustion.

Nullable reference types prevent null reference exceptions by enforcing compiler analysis and warnings for unsafe null operations.

volatile ensures read/write operations always use the most current value and prevents CPU/compiler reordering.

It is essential for correctness in low-level, lock-free synchronization.

Process memory includes stack, heap, DLL modules, native allocations, and OS buffers.

Managed heap is only the CLR-controlled memory region used for .NET objects and garbage collection.

String immutability enables thread safety, prevents accidental mutation, and supports optimizations like interning.

Metadata contains structured information about types, members, attributes, and versioning.

It powers reflection, type loading, serialization, security, and tooling support.

Boxing allocates heap memory, copies value types into objects, and causes GC overhead.

Unboxing additionally requires type checking, making both operations costly.

Weak references allow referencing an object without preventing GC from collecting it.

They are used in caching and memory-sensitive scenarios.

Reflection enables runtime inspection and invocation of types but is slower, bypasses compile-time type checks, exposes internals, and increases security risks.

The .NET GC uses reachability analysis, not reference counting. Circular references pose no issue unless unreachable from GC roots.

Memory barriers prevent reordering and enforce visibility guarantees across threads. They are essential in lock-free algorithms.

Attributes add metadata used by frameworks for configuration, validation, serialization, and behavioral modification.

Stack value types allocate fast with no GC overhead.

Boxed values allocate on the heap, increasing memory usage and GC costs.

Type erasure removes generic type information at compile time (Java). C# retains generic metadata at runtime, improving performance and type safety.

AppDomains provided isolation and sandboxing in .NET Framework. .NET Core replaces them with AssemblyLoadContext.

Exceptions trigger stack unwinding, metadata discovery, and context capturing, making them significantly slower than normal execution.

They should be used only for true exceptional situations—not control flow.

A delegate is a type-safe reference to a method. It defines a method signature and allows methods to be stored and invoked dynamically.

Delegates enable callbacks, event-driven programming, extensibility, and loose coupling by allowing execution of unknown methods at runtime.

Multicast delegates can reference multiple methods. When invoked, they call each method sequentially.

They are used for audit logging, notifications, UI event pipelines, and scenarios requiring multiple actions on a single trigger.

Action represents methods that return void, while Func represents methods that return a value.

They reduce the need for custom delegate declarations and simplify modern C# programming.

Events wrap delegates to enforce encapsulation. Only the declaring class can invoke the event, while external components may subscribe or unsubscribe.

Events implement the publisher–subscriber pattern for decoupled communication.

The publisher–subscriber model allows components to react to changes without tight coupling.

Publishers broadcast notifications without knowing subscribers, improving modularity and scalability.

async/await enables writing asynchronous code in a synchronous style, avoiding callback complexity.

It improves scalability by freeing threads during I/O waits.

The synchronization context determines where continuation runs after an await.

UI apps return to the UI thread; ASP.NET Core uses a context-free model to improve throughput.

Thread pools reuse threads, reducing creation overhead and improving performance.

They optimize concurrency through heuristics and balancing strategies.

Shared data introduces race conditions, stale reads, memory-order issues, and partial updates.

Proper synchronization is required to ensure correctness.

Mutex allows exclusive access to a resource; Semaphore limits concurrent access.

Both prevent race conditions but may cause contention when misused.

Lock-free operations rely on atomic CPU instructions instead of locks.

They improve scalability and reduce latency in high-concurrency environments.

Generics provide compile-time type checking, eliminate unsafe casts, and avoid boxing for value types.

They enhance performance and enable reusable APIs.

Generic constraints restrict the types permitted in generics, enabling safer and more expressive generic code.

They allow accessing members safely based on constraints.

Covariance allows using derived types where base types are expected. Contravariance allows the opposite.

They enable flexible delegate and interface usage.

List uses a dynamically resizing array. When full, it grows and copies elements.

Provides fast indexing but costly mid-list insertions.

Dictionary uses a hash table. The key's hash determines its bucket for near O(1) lookups.

Good hashing minimizes collisions, improving performance.

Collisions occur when two keys map to the same bucket. They are handled via chaining or probing.

Good hash code implementation minimizes collisions.

The load factor measures how full a hash table is. When exceeded, resizing and rehashing occur to maintain performance.

Each data structure is optimized for specific operations. Incorrect choice leads to wasted CPU cycles and memory overhead.

Understanding internal behavior is essential for building high-performance systems.

The CLR pipeline includes:

• C# code parsed by Roslyn into IL + metadata.
• IL stored in assemblies (.dll/.exe).
• CLR loads assemblies via Assembly Loader and verifies IL.
• JIT compiles IL to native machine code using RyuJIT and tiered compilation.
• Execution occurs under GC, exception handling, and type-safety rules.
• Supports JIT, AOT, ReadyToRun, and NativeAOT execution models.

The .NET Memory Model defines visibility and ordering guarantees:

• Reordering may occur unless prevented by barriers.
• volatile ensures visibility but not atomicity.
• lock, Monitor, Interlocked insert full memory fences.
• Handles cache coherency, tearing, and ABA issues.
• More relaxed than Java regarding visibility rules.

Value types are stored inline on the stack or inside objects. Reference types reside on the managed heap.

Boxing allocates new objects with headers and method table pointers. Inline struct fields avoid indirection and improve performance.

A .NET object contains:

• Object Header: Method Table pointer + Sync Block index.
• Aligned fields with padding.
• Method Table with hierarchy, vtable, and GC info.

Generations:

• Gen0: short-lived objects.
• Gen1: buffer generation.
• Gen2: long-lived objects; full GC expensive.
• LOH: >= 85KB, collected only in full GC.
• POH introduced for pinned objects.
• GC modes: Server, Workstation, Concurrent.

Tier 0 emits fast, minimally optimized code. Tier 1 recompiles hot methods with optimizations.

Tiered PGO improves performance for long-running APIs.

Differences:

• lock/Monitor: lightweight, thread-level.
• Mutex: cross-process synchronization.
• Semaphore: limits concurrent entries.
• SpinLock: busy-wait for low contention.
• ReaderWriterLockSlim: optimized for read-heavy workloads.

Compiler rewrites async methods into state machines stored as structs or classes.

Await posts continuations to SynchronizationContext or thread pool.

Avoid capturing context for performance.

Intern pool stores unique string instances for process lifetime.

Benefits: deduplication of literals. Harmful: unbounded memory use if interning user input.

• Reflection: slow metadata inspection.
• Reflection.Emit: runtime IL generation.
• Expression Trees: build code graphs; compile to delegates.
• Source Generators: compile-time code generation.

Uses global + per-thread queues, work-stealing, and hill-climbing algorithm to adjust worker count.

Long-running work should use TaskCreationOptions.LongRunning.

Delegates can be:

• Open/closed static
• Open/closed instance
• Multicast (invocation list)

Captured variables create hidden closure classes.

Roslyn provides AST, syntax trees, semantic models, analyzers, and source generation. It is a compiler-as-a-service.

out = covariance, in = contravariance.

Allows safe substitutability. Includes delegate variance, IEnumerable variance, and array pitfalls.

AppDomains provided isolation but were heavy and difficult to unload.

.NET Core replaced them with AssemblyLoadContext.

IL, CIL, and MSIL are the same thing: platform-independent intermediate language.

Flow:

• Throw triggers stack unwinding.
• Search for handlers.
• First-chance and second-chance exceptions.
• finally, fault blocks executed.
• Managed/unmanaged transitions handled by the runtime.

Strong naming gives a unique identity but not security.

Authenticode signing verifies publisher identity.

Assembly identity affects binding and version resolution.

Metadata includes type, method, field tables, attributes, and generic constraints.

CLR uses it for JIT compilation, verification, reflection, and type loading.

• Excess allocations
• Boxing
• Hidden lambda captures
• LINQ in hot paths
• Unnecessary locks
• Sync-over-async
• Exceptions for flow control