C# Nullable Reference Types: How, When, and Why to Use or Disable Them

C# nullable reference types help catch null reference exceptions at compile time instead of runtime. Introduced in C# 8, they add null-safety annotations to your code, making the compiler warn you about potential null dereferences before they become production bugs.

Enabling nullable reference types in Your Project

Enable nullable reference types at the project level in your .csproj:

<PropertyGroup>
  <Nullable>enable</Nullable>
</PropertyGroup>

For granular control, use #nullable directives:

#nullable enable
public string? GetUserName(int userId)
{
    var user = _userRepository.Find(userId);
    return user?.Name; // Compiler knows this might return null
}
#nullable disable

Essential nullable reference types Syntax with Nullable Objects

Mark nullable types with ? and handle nullable class objects properly:

public class User
{
    public string Name { get; set; } = string.Empty;
    public string? Email { get; set; } // Can be null
}

public class UserService
{
    public User? FindUser(int id) // Method can return null
    {
        return _repository.GetById(id); // Might return null
    }
    
    public void ProcessUser(User? user)
    {
        if (user is null) return;
        
        Console.WriteLine(user.Name); // Safe - null check above
        Console.WriteLine(user.Email?.ToUpper()); // Safe - conditional access
    }
    
    public void ProcessLegacyData(User data)
    {
        // Only use ! when you're absolutely certain
        var result = GetUserFromCache()!.Process(data);
    }
}

When to Use nullable reference types

nullable reference types shine in these scenarios:

• Public APIs - Clear contracts about what can be null
• Data layer - Entity properties that map to nullable database columns
• Domain models - Optional relationships and properties
• New projects - Built-in null safety from day one

When to Disable nullable reference types

Turn off nullable reference types when they create more noise than value:

• Legacy codebases - Massive warning floods during migration
• Third-party integrations - Libraries without nullable reference type support
• Generated code - Auto-generated classes that don’t need null checks

Key Takeaway

Treat nullable reference types as guardrails, not handcuffs. They’re most valuable in public APIs and new code where null-safety improves maintainability. For legacy systems or third-party integrations, selective disabling keeps your focus on code that actually benefits from null-safety annotations.

Start with nullable reference types enabled in new projects, then disable them strategically where the warnings don’t add value to your development workflow.

FAQ