Skip to content

C# Interview Guide: Records, Nullable Reference Types, and Pattern Matching

Q3 — Explain the C# Type System: Records, Nullable Reference Types, and Pattern Matching Level: Mid-Level | Topic: C# Fundamentals Records (C# 9+) Records are compiler-synthesised types that provide value equality , immu...

Ekanatha Reddy Urivakili12 min2,060 words

Q3 — Explain the C# Type System: Records, Nullable Reference Types, and Pattern Matching

Level: Mid-Level | Topic: C# Fundamentals

The C# type system has evolved rapidly over recent versions, introducing powerful features to enhance immutability, null safety, and expressiveness. This guide covers three pivotal additions that every mid-level C# engineer should master for interviews and practical architecture: Records (C# 9+), Nullable Reference Types (C# 8+), and Pattern Matching (C# 9 to 12). We will deepen your understanding with architecture-level diagrams, trade-off tables, and real-world-like code examples to help you ace both interviews and production design.


Records (C# 9+)

Records are a major addition to the C# type system designed for value equality and immutability while maintaining concise syntax. They enable non-destructive mutation via with-expressions, which produce new copies without altering the original instance.

There are two flavors:

  • record class: reference type by default, inheriting from object, with compiler-generated value-equality. Ideal for larger or shared data.
  • readonly record struct: value type allocated on the stack, enforced immutability with readonly, best suited for small, frequently used immutable data to minimize GC pressure.

How Records Work Architecturally

Records override Equals(), GetHashCode(), and ToString() to reflect values of the properties instead of references. The compiler generates:

  • A primary constructor from positional parameters.
  • Value-based equality members.
  • Deconstruction methods.
  • With expressions producing shallow copies with some fields changed.

Records HLD Diagram

classDiagram
    class RecordClass {
        +string Id
        +decimal Total
        +DateTime PlacedAt
        +bool Equals(RecordClass other)
        +int GetHashCode()
        +RecordClass With(...)
    }
    class RecordStruct {
        +decimal Amount
        +string Currency
        +RecordStruct With(...)
        +RecordStruct Add(RecordStruct other)
    }
    RecordClass <|-- OrderDto
    RecordStruct <|-- Money

Class diagram illustrating the key generated members of record class and readonly record struct.


Nullable Reference Types (NRT) (C# 8+)

By default, C# reference types have always been nullable, which causes NullReferenceException to be the most common runtime error. Nullable Reference Types (NRT) introduce static null safety checking.

When you enable NRT in your .csproj:

<PropertyGroup>
    <Nullable>enable</Nullable>
</PropertyGroup>
  • Plain reference types (like string) are non-nullable by default.
  • You must explicitly annotate nullable types with ? (e.g., string?).
  • The compiler analyzes code flows to warn about possible null dereferences.
  • This moves nullability checks from runtime to compile time for better code safety.

Nullable Reference Types: Trade-Offs

ProsCons
Catches possible null dereferences during compile-timeRequires possibly extensive code annotation/refactoring
Improves code documentation and intent clarityCan be cumbersome in legacy codebases
Reduces runtime NullReferenceException in productionNull forgiveness operator (!) can be misused
Encourages defensive programming patternsTooling and libraries must be NRT-aware to avoid warnings

Pattern Matching (C# 9–12)

Pattern matching introduces concise, expressive syntax for branching logic based on type, shape, or data content. It eliminates verbose if-else chains, often cluttered with null-checks.

Pattern Matching Enhancements

  • Switch expressions simplify complex conditions into a single expression returning a value.
  • Property patterns allow matching on nested property values.
  • Positional patterns support matching on record or tuple deconstruction.
  • List patterns (C# 11) enable matching sequence structures.
  • Relational patterns match numeric bounds (e.g., > 10 and < 100).
  • Logical patterns combine patterns with and, or, not.

Pattern Matching Sequence Diagram Example

sequenceDiagram
    participant Client
    participant ShapeService
    Client->>ShapeService: Request Area(Shape)
    ShapeService->>ShapeService: switch on shape type and properties
    alt Circle
        ShapeService->>Math: Calculate π * r²
        Math-->>ShapeService: Area value
    else Rectangle
        ShapeService-->>ShapeService: Calculate width * height
    else Null
        ShapeService-->>Client: throws ArgumentNullException
    end
    ShapeService-->>Client: Return Area

Sequence diagram of pattern matching dispatch based on Shape type.


Code Examples

Here are expanded, runnable C# examples illustrating these features.

Minimal Records Example

public record Person(string FirstName, string LastName);

var p1 = new Person("Eka", "Natha");
var p2 = p1 with { LastName = "Smith" };

Console.WriteLine(p1);  // Output: Person { FirstName = Eka, LastName = Natha }
Console.WriteLine(p2);  // Output: Person { FirstName = Eka, LastName = Smith }
Console.WriteLine(p1 == p2); // False — different values

Note how with creates a non-destructive copy with changed property.

Realistic Nullable Reference Types and Pattern Matching Example

#nullable enable

public record User(string Username, string? Email);

public class UserService
{
    public string GetUserDisplayEmail(User? user)
    {
        if (user is null)
            throw new ArgumentNullException(nameof(user));

        // Pattern matching with property check and null coalescing
        return user.Email switch
        {
            null => "No email provided",
            string email when email.EndsWith("@company.com") => $"{email} (Company)",
            string email => email
        };
    }
}

var user1 = new User("eka", null);
var user2 = new User("john", "john@company.com");

var service = new UserService();

Console.WriteLine(service.GetUserDisplayEmail(user1));  // No email provided
Console.WriteLine(service.GetUserDisplayEmail(user2));  // john@company.com (Company)

Notice comprehensive null safety with NRT enabled and the power of switch pattern matching on nullable properties.


Common Trap: The Null-Forgiving Operator (!)

The ! operator silences the compiler’s null warnings but doesn't fix runtime null dereferences:

public string GetName(User? user)
{
    return user!.Username; // Suppresses warning but can throw at runtime if user is null
}

Observability Guidance for C# Type System Features

While the type system features themselves don’t emit logs or metrics, understanding how to observe your C# applications that leverage these features is key for robust architecture.

What to Log

  • Record instantiations and mutations — especially when with creates new instances in business-critical flows.
  • Nullability violations — log warnings when unexpected null values are detected, e.g., before throwing exceptions.
  • Pattern matching fallbacks — log when unknown patterns or null inputs reach default cases.

Example structured log entry (using Microsoft.Extensions.Logging and Serilog):

{
  "Timestamp": "2024-06-30T10:00:00Z",
  "Level": "Warning",
  "Message": "Unexpected null encountered in UserService.GetUserDisplayEmail",
  "UserId": null,
  "StackTrace": "UserService.cs:45",
  "EventId": 1001,
  "SourceContext": "MyApp.UserService"
}

Key Metrics

Use standard RED metrics for service methods that utilize these features:

MetricDescriptionExample
RequestsNumber of calls into service/methodTotal calls to methods processing Records & Pattern matches
ErrorsNumber of failed callsCount of ArgumentNullExceptions or NotSupportedExceptions
DurationLatency of executionTime spent in pattern matching code or record operations

Resource USE metrics (CPU, memory, GC pressure) are useful for assessing the impact of heavy use of immutable records or large pattern matching chains.

Distributed Tracing Example (with OpenTelemetry in C#)

using OpenTelemetry.Trace;

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddSource("MyCompany.MyProduct.UserService")
    .AddConsoleExporter()
    .Build();

var tracer = tracerProvider.GetTracer("MyCompany.MyProduct.UserService");

using var span = tracer.StartActiveSpan("CalculateArea");
try
{
    var area = Area(shape);
    span.SetAttribute("shape.type", shape.GetType().Name);
    span.SetAttribute("area.value", area);
}
catch (Exception ex)
{
    span.RecordException(ex);
    span.SetStatus(Status.Error.WithDescription(ex.Message));
    throw;
}
finally
{
    span.End();
}

SLI/SLO and Alerting for Type System Features

SLISLO TargetAlert ConditionPager Worthy?
Percentage of null violations< 0.1 % of callsNullReferenceException rate spikes over 0.5%Yes
Pattern match failures< 1 % of requests handledIncrease in NotSupportedException on patternsYes
Average latency of key methods< 100 ms 95th percentileLatency >300 ms sustained for 5 minsYes

Records: Deep Dive into Equality and Immutability Internals

Records in C# fundamentally change the shape of data modeling by prioritizing value semantics over reference semantics. Understanding how the compiler synthesizes code is crucial for maximizing both correctness and performance.

How the Compiler Implements Equals and GetHashCode

The compiler-generated Equals method in a record class performs the following steps:

  • Checks for reference equality first (ReferenceEquals(this, other)) for a quick path.
  • Returns false if other is null or type differs.
  • Compares each positional property (and any additional properties included in equality) by their Equals method recursively.
  • For nested records, this comparison cascades, ensuring deep equality.

GetHashCode combines the hash codes of all positional properties using a hashing algorithm that balances collision resistance and performance. Typically, the compiler uses the standard HashCode.Combine method introduced in .NET Core 2.1+.

// Simplified example of generated Equals pattern
public override bool Equals(object? obj)
{
    if (ReferenceEquals(this, obj)) return true;
    if (obj is null || obj.GetType() != GetType()) return false;

    var other = (Person)obj;
    return FirstName == other.FirstName && LastName == other.LastName;
}

// Simplified GetHashCode example
public override int GetHashCode()
{
    return HashCode.Combine(FirstName, LastName);
}

Immutability and Non-Destructive Mutation

Under the hood, the with expression compiler-generated method creates a shallow copy of the record, typically:

  • Allocates a new record instance.
  • Copies all fields.
  • Applies modified values provided in the with expression.

Because records are immutable by default, this shallow copy is safe and efficient, but beware of mutable reference-type fields within records, which can subvert immutability if those objects can change externally.

// Generated with method in record class
public Person With(string? FirstName = null, string? LastName = null)
{
    return new Person(
        FirstName ?? this.FirstName,
        LastName ?? this.LastName);
}

Value Type Records: Readonly Constraints and Copy Semantics

Readonly record structs are copied by value rather than by reference, avoiding heap allocations which reduce GC pressure in hot paths.

  • All fields marked readonly — any mutation causes compile-time error.
  • Methods marked as readonly to prevent accidental mutation.
  • Equality is bitwise for primitive fields but overridden to ensure semantic correctness in user-defined types.

A Worked Production Scenario: Building a Domain Model with Records and Pattern Matching

Consider a simplified e-commerce domain where orders, discounts, and payments are modeled with C# records and pattern matching for business logic.

Domain Models

public record Money(decimal Amount, string Currency);

public abstract record Discount;

public record PercentageDiscount(decimal Percentage) : Discount;

public record FixedAmountDiscount(Money Amount) : Discount;

public record Order(
    Guid Id,
    List<Money> ItemPrices,
    Discount? AppliedDiscount = null
);

Calculating Final Order Total with Pattern Matching

Business rules:

  • If no discount, sum item prices.
  • Percentage discount applies percent off subtotal.
  • Fixed amount subtracts fixed money value.
  • Reject discount currencies that don't match the order currency.
public class OrderService
{
    public Money CalculateTotal(Order order, string currency)
    {
        var subtotal = SumPrices(order.ItemPrices, currency);

        var discountAmount = order.AppliedDiscount switch
        {
            PercentageDiscount pd => new Money(subtotal.Amount * (pd.Percentage / 100m), currency),
            FixedAmountDiscount fad when fad.Amount.Currency == currency => fad.Amount,
            FixedAmountDiscount => throw new InvalidOperationException("Discount currency mismatch."),
            null => new Money(0, currency),
            _ => throw new NotSupportedException("Unknown discount type.")
        };

        var totalAmount = subtotal.Amount - discountAmount.Amount;
        if (totalAmount < 0) totalAmount = 0;

        return new Money(totalAmount, currency);
    }

    private Money SumPrices(List<Money> prices, string currency)
    {
        decimal sum = 0;
        foreach (var p in prices)
        {
            if (p.Currency != currency) 
                throw new InvalidOperationException("Mixed currency items are unsupported.");
            sum += p.Amount;
        }
        return new Money(sum, currency);
    }
}

What to Notice

  • Pattern matching switches on runtime type and property conditions (when guard).
  • Immutable data (records) makes business logic referentially transparent and thread-safe.
  • The approach clearly separates concerns and gives extensibility to discounts.
  • Error paths throw explicit exceptions for invalid input; strict nullability helps avoid silent errors.

Edge Cases and Failure Modes for Nullable Reference Types and Pattern Matching

Robust C# applications must anticipate subtle scenarios with NRT and pattern matching.

Nullable Reference Types: Common Pitfalls

ScenarioExplanationMitigation Practice
Nullable parameter passed where non-null expectedMay cause compiler warning but still fail at runtimeUse parameter validation (ArgumentNullException.ThrowIfNull())
Overuse of null-forgiving operator (!)Suppresses warnings, hides unsafe assumptionsAvoid ! unless absolutely sure
Legacy libraries without NRT annotationsCause false positives and excessive warningsUse <Nullable>annotations</Nullable> to adjust or shim nullability annotations
Ambiguous null flow analysis in complex expressionsCompiler sometimes cannot guarantee null safetyUse inline guards or explicit null checks

Pattern Matching Failure Modes

ScenarioExplanationMitigation Practice
Failure to handle null in switch expressionsnull is not matched by default switch armsAlways add null case or use null-accepting patterns
Missing cases for new derived typesCan cause NotSupportedException on unknown inputUse exhaustive patterns and enable compiler warnings for incomplete patterns
Complex patterns causing performance degradationExcessive nested or large pattern expressions grow evaluation timeExtract logic, pre-filter inputs, or simplify patterns
Mixing mutable state inside pattern matchingMutation during pattern evaluation leads to threading issuesAvoid side effects in patterns

Performance Considerations: Records and Pattern Matching at Scale

Designing performant production systems requires understanding where these features impact runtime costs.

Records Allocation and Memory Use

FeatureCost EstimateRecommendations
record class heap allocationOne object per instance; GC overhead grows with instance countPool frequently used records or use structs for small data
readonly record struct on stackMinimal allocation overheadUse for small, high-frequency value data like Money, Coordinates
with expressionsCreates new instance per mutationMinimize deep copies on hot paths
Boxing of struct recordsCauses heap allocation on interface or object usageAvoid boxing; prefer generics or concrete types

Pattern Matching Cost Profile

Pattern TypeCost CharacteristicsNotes
Type patterns (is T)Fast, JIT-optimized type checksEfficient for type dispatch
Property patternsAdditional property access overheadCheap if simple properties; expensive for deep trees
Positional patternsDeconstruction calls add minor overheadDependent on custom Deconstruct performance
List patternsRequires enumeration and length checksCan be expensive on large collections
Logical and relational patternsMinimal overhead, compile-time optimizedUse for readable range/filtering expressions

Designing for Observability: Logging and Metrics Patterns for Null-Safety and Records

Advanced use of these features in production requires tailored observability strategies to detect bugs and performance issues early.

Logging Recommendations

  • Log creation of domain records with key identifiers for traceability.
  • Log all null validation failures with call stack and input snapshot.
  • For pattern matching fallbacks, log encountered unknown types or unexpected nulls.
  • Use structured logs with context (e.g., user ID, operation, source file).
_logger.LogWarning("Pattern matching fallback in Discount handler", new
{
    DiscountType = discount?.GetType().Name,
    OrderId = order.Id,
    StackTrace = Environment.StackTrace
});

Metrics to Capture

  • Count of null-related exceptions: track ArgumentNullExceptions and unexpected null dereferences precisely.
  • Pattern matching fallback frequencies: signal unhandled types in switch expressions.
  • Allocation rates of record instances: via .NET runtime counters; high rates indicate potential GC pressure.
  • Latency of business logic methods using records and patterns: enables capacity planning and alerting.

Distributed Tracing: Attribute Suggestions

When instrumenting code with OpenTelemetry or Application Insights:

Attribute KeySource ExampleDescription
record.typePerson, Order, Money instantiationsIdentifies the record type in the trace span
pattern.match.resultMatched, Fallback, NullOutcome of pattern matching logic
nullable.parameter.checkedtrue or falseWhether null checks passed before processing
exception.typeException type on failureException thrown during pattern or record use

Decision Checklist: When and How to Use Records, Nullable Reference Types, and Pattern Matching

Decision PointRecommendationReason
Do you need immutable data with value equality?Use record class or readonly record struct based on sizeSimplifies equality, immutability, and with-expressions
Are performance and memory pressure critical?Prefer readonly record struct with care for boxingLimits heap allocation and GC overhead
Is null safety a priority in your codebase?Enable Nullable Reference Types and enforce null checkingCatches bugs early, improves maintainability
Do you deal with complex type or shape dispatch?Use pattern matchingMakes code expressive, eliminates brittle conditionals
Do you need exhaustive runtime type safety?Combine pattern matching with switch expressions + warningsAvoid unhandled cases, enable compiler enforcement
Are you working with legacy codebases?Gradually migrate to nullable reference types; isolate codeAvoids massive refactor and breaks

By mastering these internals and practical scenarios, you will architect well-typed, safe, high-performance C# systems that leverage modern language features to their fullest. Observability and proactive null handling are your best defense against runtime surprises in production.

Summary

  • Records simplify immutable value models with built-in value equality and with support.
  • Nullable Reference Types dramatically improve null safety at compile time.
  • Pattern Matching enables sophisticated, readable, and concise conditionals across types and data shapes.
  • Understanding their benefits, pitfalls, and appropriate use cases deepens your mastery of modern C#.

By supplementing your knowledge with architecture diagrams, careful trade-off consideration, and observability practices, you will be better prepared to design robust C# applications and confidently articulate these concepts in interviews.


References


This enhanced article now thoroughly covers your original topics with diagrams, detailed explanations, trade-offs, production-ready code examples, and observability implementation advice—an 8–15 minute read for experienced C# engineers preparing for interviews or system design discussions.