C# Deep Dive: Type System, Generics, Async & Compiler Internals

01 Type System — The Foundation

C#'s type system is the cornerstone of the language. All types inherit from System.Object, yet they differ fundamentally in memory allocation, assignment behavior, and performance characteristics.

Value Types vs Reference Types

This is the most basic and frequently questioned distinction in C#. Value types ( struct, int, bool, etc.) default to stack allocation and copy the entire data on assignment; however, if boxed, used as a class field, or captured in an async method, they may end up on the heap. Reference types ( class, string, object, etc.) always allocate on the managed heap ; their object header contains a sync block index and a type handle. Consequently, reference-type assignment copies only the memory address (a 4- or 8-byte reference), not the entire object.

Architect's Perspective: The choice between value and reference types directly impacts memory layout and GC pressure. High-frequency small data structures should prefer struct, but beware — oversized struct s (exceeding 16 bytes) can incur copy costs on parameter passing that outweigh heap-allocation savings.

Special Type: string

string

is a reference type with special behavior: it is immutable — every modification creates a new instance. This design is driven by the string intern pool and thread-safety considerations. StringBuilder exists to solve the memory-allocation overhead of frequent string operations.

Boxing and Unboxing

Converting a value type to object or an interface type triggers boxing — allocating an object on the heap and copying the value. Unboxing is the reverse. The performance penalty comes from heap allocation and additional GC pressure ; avoid boxing in hot paths.

Interview Follow-up: "What is the memory-layout difference between int and int??" — Nullable<T> is itself a value type, using a HasValue flag to indicate presence of a value, and does not box unless cast to object.

02 Object-Oriented Programming — Three Pillars

Encapsulation

Access modifiers control member visibility: public, private, protected, internal, protected internal, private protected. Properties implement encapsulation via get / set / init accessors; auto-properties are syntactic sugar — the compiler generates a private backing field and default accessors.

Inheritance

C# supports single inheritance — a class can inherit only one base class. virtual methods can be overridden ( override), abstract members must be implemented in derived classes, and sealed prevents further inheritance. Base-class constructors are invoked via base().

Architect's Perspective: Inheritance is static and compile-time determined. In architecture design, composition over inheritance is the safer choice — reuse behavior through interfaces and dependency injection, avoiding the fragility of deep inheritance hierarchies.

Polymorphism

Compile-time polymorphism: Method overloading — same name, different parameters; the compiler decides which to call.

Runtime polymorphism: Method overriding — via the virtual method table (VTable) the runtime decides which implementation to invoke.

Abstraction

Abstract class: Can contain both abstract and implemented members; cannot be instantiated.

Interface: Defines a contract. C# 8.0+ supports default interface methods (DIM). A class may implement multiple interfaces, which is the key mechanism to overcome single-inheritance limits.

Interview Follow-up: "What problem does default interface implementation (DIM) solve?" — Primarily to add new methods to an interface without breaking existing implementations; it is an API evolution scenario.

03 Generics — Type-Safe Reuse

Generics are one of C#'s most powerful features; they allow types as parameters , enabling type-safe code reuse.

Core Mechanism

Generics are constructed at runtime by the CLR: for each value-type argument, independent native code is generated; for all reference-type arguments, a single shared code copy is used (because reference types occupy the same size).

Covariance and Contravariance

These are the most confusing concepts in generic interviews:

Covariance ( out ): Allows only output (return), not input. Example: IEnumerable<out T> — IEnumerable<string> can be assigned to IEnumerable<object>.

Contravariance ( in ): Allows only input (parameters), not output. Example: IComparer<in T> — IComparer<object> can be assigned to IComparer<string>.

Why can't List<string> be assigned to List<object>? Because List<T> is mutable (has an Add(T) method); allowing the assignment would break type safety — you could add an int to a List<object> that actually points to a List<string>.

Architect's Perspective: Generic constraints ( where T : class, struct, new(), base-class constraints) are a compile-time checking lever. When designing framework APIs, proper use of generic constraints can shift runtime errors to compile time .

04 Delegates and Events

Delegate Essence

A delegate is a type-safe method pointer . It is a class (inheriting from System.MulticastDelegate) that wraps one or more method references. The power of delegates lies in passing methods as parameters , enabling callbacks, strategy patterns, etc.

Multicast Delegates

Delegates can be chained; invocation executes all methods in order.

Event Essence

An event is a wrapper around a delegate , providing the publish-subscribe pattern . Key differences:

Delegate: Can be invoked and assigned outside the class (breaks encapsulation).

Event: Can only be raised inside the class (via Invoke); external code can only += or -= to subscribe/unsubscribe.

Events are the native C# implementation of the Observer design pattern.

05 Lambda Expressions and LINQ

Lambda Expressions

A lambda is a lightweight anonymous function used to create delegate instances or expression trees. The compiler must know two things: parameter types and return type — together they form the delegate type .

// Lambda → Delegate
Func<int, int> square = x => x * x;

// Lambda → Expression Tree (parsable as data structure)
Expression<Func<int, int>> expr = x => x * x;

LINQ (Language Integrated Query)

LINQ has two flavors:

LINQ to Objects: Queries in-memory collections, based on delegates .

LINQ to SQL/EF: Queries databases, based on expression trees — the query is parsed into an expression tree and then translated to SQL.

Architect's Perspective: Understanding LINQ's deferred execution is critical — operators like Where, Select execute only when iterated. Overusing ToList() eagerly materializes results, causing unnecessary allocations and performance loss.

06 Async/Await — What the Compiler Does Behind the Scenes

async

/ await was introduced in C# 5.0, but its underlying mechanism is far more complex than it appears.

State Machine

The compiler transforms an async method into a state machine (implementing IAsyncStateMachine). Each await records the current state; when the awaited task completes, execution resumes from the correct location. AsyncTaskMethodBuilder manages the task's lifecycle.

SynchronizationContext

await

by default attempts to return to the original context — UI threads have a SynchronizationContext, so code after await resumes on the UI thread. ConfigureAwait(false) tells the compiler "I don't need to return to the original context," reducing unnecessary thread switches.

Architect's Perspective: In library code always use ConfigureAwait(false) to avoid deadlocks and improve performance. In application code (e.g., UI layer) you may need to preserve the context.

Interview Follow-up: "What's wrong with async void? When can it be used?" — Exceptions from async void cannot be caught and will crash the process. Only event handlers may use async void; all other scenarios must use async Task.

07 Reflection — The Foundation of Frameworks

Reflection Principle

Reflection is the mechanism for dynamically inspecting program structure , based on metadata — program structure information stored in the PE file. Any framework seeking flexibility and extensibility relies on reflection.

Core Use Cases

Runtime type inspection ( Type objects)

Dynamic instance creation ( Activator.CreateInstance)

Dynamic method invocation/field access ( MethodInfo.Invoke)

Reading custom attributes ( Attribute)

Performance Considerations

Reflection overhead mainly comes from metadata lookup and security checks . Optimizations include:

Cache Type objects and MethodInfo (avoid repeated lookups)

Use Expression<T> or Emit to generate dynamic code (near-native performance)

.NET 8+'s System.Reflection.Metadata provides more efficient metadata reading

DynamicMethod vs Expression Trees

DynamicMethod: Emits IL directly; higher performance but more complex to write.

Expression Trees: More readable, but require an extra compilation step; slightly lower performance.

08 Span<T> and Memory<T> — Zero-Allocation Memory Access

Introduced in .NET Core 2.1, this is a revolutionary feature and a high-frequency architect interview topic.

Span<T>

Is a ref struct , stack-only .

Safely accesses contiguous memory (arrays, stack memory, unmanaged memory).

Can avoid array bounds checks (via pointer operations).

Does not support async scenarios (cannot be stored on the heap).

Memory<T>

Is a regular struct , heap-storable .

Suitable for async scenarios (can be captured by await).

Obtain Span<T> via Memory<T>.Span. stackalloc allocates arrays on the stack , lifetime limited to the current method stack frame. Combined with Span<T>, it enables zero-allocation high-performance memory operations.

09 Source Generators — Compile-Time Code Generation

Source generators, introduced in .NET 5, are a compile-time metaprogramming technology. They analyze code during compilation and generate new source code , which the compiler then compiles alongside the original code.

Comparison with Reflection

Reflection: Runtime dynamic lookup; has performance overhead; cannot be used in AOT scenarios.

Source Generators: Compile-time generation; zero runtime overhead ; fully compatible with Native AOT.

Typical Applications

Auto-implement INotifyPropertyChanged Generate strongly-typed serialization code from JSON/XML

Generate entity classes from database schema

Compile-time dependency-injection container registration

Architect's Perspective: For architectures pursuing extreme performance and AOT compatibility , source generators are the best alternative to reflection. When designing frameworks, prefer source generators over runtime reflection.

Conclusion

C# is the architect's most important tool. Key takeaways:

Type System: Value types (stack, copy) vs reference types (heap, by-reference). string immutable; boxing/unboxing has cost.

OOP: Single inheritance, multiple interfaces. Composition over inheritance is an architectural best practice.

Generics: Runtime construction; reference types share code. Covariance ( out) and contravariance ( in) are key to type safety.

Delegates & Events: Delegates are type-safe method pointers; events wrap delegates implementing Observer pattern.

Lambda & LINQ: Lambdas compile to delegates or expression trees. LINQ to SQL relies on expression trees translated to SQL.

Async/Await: Compiler generates a state machine. ConfigureAwait(false) for library optimization.

Reflection: Metadata-based dynamic programming; framework cornerstone. Performance-sensitive scenarios use expression trees or source generators instead.

Span/Memory: Zero-allocation memory access. Span<T> is a ref struct (stack); Memory<T> supports async.

Source Generators: Compile-time code generation; zero runtime overhead; reflection's AOT-friendly replacement.