Equality, Nullability & Dynamic

This topic gathers the places where C# demands a precise model of a type rather than intuition. Equality splits into reference and value comparison, and the type's category decides which you get by default. null for a value type is expressed through Nullable<T> — a wrapping struct, not a null reference. Immutability means that "editing" a string actually creates a new object. And var, object, and dynamic differ not in spelling but in when the type is resolved and members are checked.

The common thread across all layers is the distinction between value and reference types, and between what the compiler knows (the static type) and what the object has at runtime (the actual type). A candidate who keeps that distinction in mind answers the tricky == / Equals, int?, and var / dynamic questions with confidence instead of guessing. The full map lives in the layers below.

Topic map

• Value Equality — value types compare by value; the Equals/GetHashCode contract and records.
• Reference Equality — == versus Equals, ReferenceEquals, why string compares by value.
• Nullable Types — Nullable<T>/int? as a struct, HasValue/Value, the ?? and ?. operators.
• Immutability — state cannot change after construction; string, StringBuilder, readonly, records.
• dynamic vs object — a static base type versus binding members at runtime.
• Type Inference (var) — var infers a static type at compile time and is not dynamic.

Common traps

Interview relevance

Interviewers love these "for understanding" questions because the intuitive answer is usually wrong. A candidate who separates the static type from the actual type, and remembers that value and reference types behave differently, answers precisely instead of by guesswork.

Typical checks:

• When == gives reference versus value equality, and why string is a special case.
• Why overriding Equals requires overriding GetHashCode.
• That int? is the struct Nullable<T>, and how to read its value safely.
• What immutability of string means and when to reach for StringBuilder.
• How var (static inference at compile time) differs from dynamic (runtime binding).

Common wrong answer: "var is dynamic typing, the type is decided at runtime". That opens the discussion that var is a purely compiler-side inference of a static type, equivalent to the explicit type name — and that runtime binding is a different keyword entirely, dynamic.