What are nullable value types (Nullable<T>, int?) in C#? How do HasValue, Value, GetValueOrDefault, lifted operators and boxing of a null nullable work?

How I would answer this in an interview

int? is shorthand for Nullable<int>, a struct that wraps a value type with a HasValue flag. It exists because value types cannot be null, but real data often has "no value" — an optional database column, a missing JSON field, "not yet calculated". The interesting parts are the members, lifted operators and the special boxing rules.

1. What Nullable<T> is

public struct Nullable<T> where T : struct
{
    private readonly bool hasValue;
    internal T value;
    public bool HasValue => hasValue;
    public T Value => hasValue ? value : throw new InvalidOperationException("Nullable object must have a value.");
    public T GetValueOrDefault() => value;
    public T GetValueOrDefault(T defaultValue) => hasValue ? value : defaultValue;
}

• It is itself a value type: no heap allocation, just the value plus a bool (with padding, int? is 8 bytes, long? and decimal? grow similarly).
• T must be a non-nullable value type, so int?? and string? as Nullable<string> are not allowed.
• null for an int? means HasValue == false; it is not a null reference.

2. Members and how I use them

Modern idiomatic code:

if (order.DiscountPercent is decimal discount)
    total -= total * discount / 100m;

var retries = settings.MaxRetries ?? 3;

3. Lifted operators

Operators defined on T are automatically lifted to T?:

• Arithmetic and bitwise (+ - * / % & | ^ << >>): if either operand is null, the result is null. 5 + (int?)null == null.
• Equality (==, !=): null == null is true; 5 == null is false.
• Relational (< > <= >=): if either operand is null, the result is false — not null. So null < 5 and null >= 5 are both false, which breaks the usual "if not less then greater-or-equal" logic.
• bool? with & and | use three-valued (SQL-like) logic: null & false == false, null | true == true.

This mirrors SQL NULL semantics, which is why EF Core can translate them, but it trips people up in C# conditions.

4. Boxing a nullable

The runtime treats Nullable<T> specially when boxing:

• Boxing an int? with a value produces a boxed int, not a boxed Nullable<int>.
• Boxing an int? without a value produces a null reference.

int? a = 5;   object oa = a;   // boxed int
int? b = null; object ob = b;  // null
Console.WriteLine(oa.GetType());   // System.Int32
Console.WriteLine(ob is null);     // True
Console.WriteLine(ob?.GetType());  // null - GetType() on ob would throw NRE

And you can unbox a boxed int directly to int?. This makes nullable values behave sensibly in object-typed APIs, but it means you can never observe Nullable<int> via GetType() — use Nullable.GetUnderlyingType(typeof(T)) in reflection.

5. Where they show up in real systems

• EF Core: a nullable column (int NULL, datetime2 NULL) maps to int?/DateTime?. Making a property non-nullable makes the column NOT NULL in migrations.
• JSON: System.Text.Json writes null for empty nullables and can ignore them with JsonIgnoreCondition.WhenWritingNull.
• APIs: query parameters like int? page distinguish "not provided" from 0.
• Optional updates (PATCH): int? cannot distinguish "not sent" from "set to null" — that needs a wrapper like Optional<T> or JSON Patch.

6. A production example

A reporting endpoint filtered orders with if (order.CompletedAt > cutoff) and an else branch that assumed "not completed after the cutoff" meant "completed before". For orders with CompletedAt == null the comparison was false, so incomplete orders were counted as completed-before-cutoff, inflating a KPI. We rewrote it with explicit patterns (order.CompletedAt is { } done && done > cutoff) and a separate branch for null, and added test cases for null on every nullable comparison in that report.