What does default mean in C#? Explain default(T), the default literal, default values of structs, enums and reference types, and how default is used in generics and optional parameters.

1. Why "all bits zero" is the universal default

The CLR guarantees that newly allocated memory is zeroed: heap objects, arrays, and (by default) stack frames via the .locals init flag. Zeroed memory is a valid value for every type:

• A zeroed reference is null.
• A zeroed int/double/decimal is 0.
• A zeroed struct is a struct whose fields are all zeroed.

This is what makes default(T) cheap: the JIT emits an initobj instruction (for structs) or ldnull / ldc.i4.0, often just zeroing a register or using xor reg, reg. It is also why the runtime does not need to call struct constructors for arrays — new Point[1_000_000] is simply a zeroed memory block.

2. default vs new() for structs

public struct Config
{
    public int Retries = 3;          // field initialiser (C# 10)
    public Config() { }              // explicit parameterless ctor
}

var a = new Config();              // Retries = 3 (ctor runs)
var b = default(Config);           // Retries = 0 (no ctor)
var array = new Config[1];
var c = array[0];                  // Retries = 0 (array elements are zeroed, no ctor)

Activator.CreateInstance<T>() and new T() with the new() constraint call the parameterless constructor if one exists. Rule: never rely on a struct constructor running.

C# 11 also made the compiler auto-default struct fields that are not assigned in a constructor (previously error CS0171), so constructors no longer need to assign every field.

3. Default for reference types under NRT

default on a non-nullable reference type produces null with a warning (CS8625 for literal assignment, CS8603 for returns). In generic code, return default; from a method returning T (unconstrained) gives CS8603 under NRT; the fix is a T? return type or [return: MaybeNull].

4. Generic code patterns

static bool IsDefault<T>(T value) => EqualityComparer<T>.Default.Equals(value, default!);

• For value types the JIT specialises this per type and devirtualises the comparer, so it compiles to a simple comparison — no boxing.
• value is null works for unconstrained T (always false for non-nullable value types, and the JIT removes the branch entirely).
• typeof(T).IsValueType checks are constant-folded per instantiation in modern JITs.

5. default and pattern matching / switch

• case default: is not valid (default in switch statements is the fallback label); to match the default value use a constant or var x when x == default.
• In switch expressions, _ is the discard, not default.
• x is default(Money) does not compile for non-constant structs; compare with Equals or check IsDefault.

6. ImmutableArray<T> — a default-value trap in the BCL

ImmutableArray<T> is a struct wrapping a T[]. Its default has a null inner array, so calling Length or enumerating throws NullReferenceException or InvalidOperationException. That is why it exposes IsDefault and IsDefaultOrEmpty, and why record properties of type ImmutableArray<T> should be initialised to ImmutableArray<T>.Empty or [].

ArraySegment<T> and Memory<T> have similar but safe defaults (empty).

7. Serialisation and databases

• System.Text.Json: missing properties stay at their default unless marked required ([JsonRequired] or the C# required keyword). DefaultIgnoreCondition = WhenWritingDefault omits 0, false, null from output — which breaks clients that rely on explicit false.
• EF Core: a key property with its CLR default (0, Guid.Empty) is treated as not set, so EF generates a value; this is why inserting an entity with Id = 0 creates a new identity. Sentinel configuration (HasSentinel) exists in EF Core 8+ for non-default sentinels.
• SQL Server datetime cannot store 0001-01-01 (minimum is 1753); datetime2 can. A DateTime default can therefore either throw or silently store a nonsense date depending on column type.

Try it yourself

1. Create a struct with a field initialiser and a parameterless constructor; compare new(), default and an array element.
2. Call FirstOrDefault() on new List<int> { 0 } and on an empty list, and design an API that tells them apart.
3. Declare ImmutableArray<int> a = default; and call a.Length.
4. Deserialise {} into a class with an int Quantity property and a required int Quantity property.

using System.Collections.Immutable;

namespace Types;

public enum OrderStatus { Unknown = 0, Pending = 1, Shipped = 2 }   // 0 is meaningful

public struct Money
{
    public decimal Amount;
    public string Currency = "AUD";
    public Money() { }                        // C# 10: runs for new Money(), not for default
}

public static class Defaults
{
    public static void Main()
    {
        Console.WriteLine(default(DateTime));         // 1/01/0001 12:00:00 AM
        Console.WriteLine(default(OrderStatus));      // Unknown
        Console.WriteLine(new Money().Currency);      // AUD
        Console.WriteLine(default(Money).Currency is null);   // True: constructor skipped
        Console.WriteLine(new Money[1][0].Currency is null);  // True

        // FirstOrDefault ambiguity on value types
        int[] scores = [10, 20];
        Console.WriteLine(scores.FirstOrDefault(s => s > 50));      // 0: real or missing?
        Console.WriteLine(scores.FirstOrDefault(s => s > 50, -1));  // -1: explicit sentinel

        // Invalid default struct
        ImmutableArray<int> arr = default;
        Console.WriteLine(arr.IsDefault);                           // True; arr.Length would throw

        Console.WriteLine(IsDefault(0) && IsDefault<string?>(null) && !IsDefault("x"));
    }

    // Generic default comparison
    public static bool IsDefault<T>(T value) => EqualityComparer<T>.Default.Equals(value, default);

    public static async Task SaveAsync(string path, CancellationToken ct = default)
        => await File.WriteAllTextAsync(path, "ok", ct);
}