Explain the concept of nullable reference types introduced in C# 8.0.

Nullable Reference Types is a C# 8.0 feature that helps prevent null reference exceptions by making reference types non-nullable by default when enabled.

Before C# 8.0:

// Any reference type could be null
string name = null;  // Always allowed
Person person = null;  // Always allowed
// NullReferenceException was common at runtime

After C# 8.0 (when enabled):

// Non-nullable reference type (default)
string name = null;  // Compiler warning!

// Nullable reference type (explicit)
string? nullableName = null;  // OK

// Using nullable reference type
void ProcessName(string name)  // name should never be null
{
    Console.WriteLine(name.Length);  // Safe, no null check needed
}

void ProcessNullableName(string? name)  // name might be null
{
    // Compiler warns if you don't check for null
    Console.WriteLine(name.Length);  // Warning!
    
    // Proper null check
    if (name != null)
    {
        Console.WriteLine(name.Length);  // OK
    }
    
    // Or use null-conditional operator
    Console.WriteLine(name?.Length);  // OK
}

Enabling Nullable Reference Types:

Project-wide (in .csproj):

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

File-level:

#nullable enable
public class MyClass
{
    public string Name { get; set; }  // Non-nullable
}
#nullable restore

Nullable Annotations:

public class Person
{
    // Non-nullable - must be initialized
    public string FirstName { get; set; } = string.Empty;
    
    // Non-nullable - initialized in constructor
    public string LastName { get; set; }
    
    // Nullable - can be null
    public string? MiddleName { get; set; }
    
    // Nullable - optional parameter
    public string? Suffix { get; set; }
    
    public Person(string lastName)
    {
        LastName = lastName;
    }
}

// Usage
Person person = new Person("Doe")
{
    FirstName = "John",
    MiddleName = null  // OK, explicitly nullable
};

// Warning - FirstName is non-nullable
// Person invalid = new Person("Doe"); // Warning: FirstName not initialized

Null-Forgiving Operator (!):

public class UserService
{
    private string? _cachedData;
    
    public void Initialize()
    {
        _cachedData = "initialized";
    }
    
    public string GetData()
    {
        // You know it's not null, but compiler doesn't
        // Use ! to tell compiler "trust me, it's not null"
        return _cachedData!;  // Null-forgiving operator
    }
}

Nullable Attributes:

public class StringHelper
{
    // If string is not null/empty, return is not null
    public static bool IsNullOrEmpty([NotNullWhen(false)] string? value)
    {
        return string.IsNullOrEmpty(value);
    }
    
    // Method ensures parameter is not null after return
    public static void ThrowIfNull([NotNull] string? value, string paramName)
    {
        if (value == null)
            throw new ArgumentNullException(paramName);
    }
}

// Usage
string? input = GetUserInput();

if (!StringHelper.IsNullOrEmpty(input))
{
    // Compiler knows input is not null here
    Console.WriteLine(input.Length);  // No warning
}

Common Nullable Attributes:

// [NotNull] - Parameter won't be null when method returns
void EnsureInitialized([NotNull] ref string? value);

// [NotNullWhen(bool)] - Parameter is not null when method returns true/false
bool TryParse(string? input, [NotNullWhen(true)] out int result);

// [NotNullIfNotNull("parameter")] - Return is not null if parameter is not null
[return: NotNullIfNotNull("input")]
string? Process(string? input);

// [MaybeNull] - Return may be null even for non-nullable type
[return: MaybeNull]
T GetValueOrDefault<T>();

// [MemberNotNull("field")] - Ensures field is not null after method
[MemberNotNull(nameof(_cache))]
void Initialize();

Real-World Example:

#nullable enable

public class UserRepository
{
    private readonly DbContext _context;
    
    public UserRepository(DbContext context)
    {
        _context = context;  // Non-nullable, must be provided
    }
    
    // Returns nullable - user might not exist
    public User? FindById(int id)
    {
        return _context.Users.FirstOrDefault(u => u.Id == id);
    }
    
    // Returns non-nullable - throws if not found
    public User GetById(int id)
    {
        return _context.Users.First(u => u.Id == id);
    }
    
    // Parameter is non-nullable - user must not be null
    public void Save(User user)
    {
        ArgumentNullException.ThrowIfNull(user);  // C# 11+
        _context.Users.Add(user);
        _context.SaveChanges();
    }
    
    // Parameter is nullable - updates if exists
    public void UpdateIfExists(User? user)
    {
        if (user == null)
            return;
            
        _context.Users.Update(user);
        _context.SaveChanges();
    }
}

// Usage
var repo = new UserRepository(dbContext);

// Handle nullable return
User? user = repo.FindById(123);
if (user != null)
{
    Console.WriteLine(user.Name);  // Safe
}

// Or use null-conditional
Console.WriteLine(user?.Name ?? "Not found");

// Non-nullable return
User existingUser = repo.GetById(123);  // Throws if not found
Console.WriteLine(existingUser.Name);  // No null check needed

Migration Strategy:

// Step 1: Enable for new files only
#nullable enable
// Your code here
#nullable restore

// Step 2: Gradually enable per project/assembly
// <Nullable>enable</Nullable>

// Step 3: Fix warnings incrementally
// Use nullable annotations where appropriate
// Add null checks where needed
// Use ! operator sparingly for legacy code

Generic Constraints:

// T can be null
public class Container<T>
{
    private T? _value;  // Nullable for any T
}

// T must be non-nullable reference type
public class NonNullContainer<T> where T : notnull
{
    private T _value = default!;  // Must be initialized
}

// T is nullable reference type
public T? GetOrDefault<T>() where T : class
{
    return default;  // Returns null
}

Benefits:

1. Catch null reference bugs at compile-time
2. Self-documenting code (intent is clear)
3. Better IDE support and intellisense
4. Reduced NullReferenceException at runtime
5. More confident refactoring

Common Warnings:

// CS8600: Converting null literal or possible null value to non-nullable type
string name = null;  // Warning

// CS8602: Dereference of a possibly null reference
string? nullable = null;
int length = nullable.Length;  // Warning

// CS8603: Possible null reference return
public string GetName()
{
    return null;  // Warning
}

// CS8618: Non-nullable field must contain a non-null value when exiting constructor
public class Person
{
    public string Name { get; set; }  // Warning
}

Best Practices:

• Enable nullable reference types for new projects
• Use ? for truly optional values
• Avoid using ! (null-forgiving operator) unless necessary
• Add appropriate null checks
• Use nullable attributes to provide hints to compiler
• Make intent explicit in APIs