What are non-nullable reference types (NRTs) and how do they improve null safety?

Basic Introduction to NRTs

// Non-nullable string (cannot be null)
string name = "John";

// Nullable string (can be null)
string? nullableName = null;

// Attempting to assign null to a non-nullable string will produce a warning
// name = null; // Compiler warning: CS8600 Converting null literal or possible null value to non-nullable type.

Enabling NRTs in Your Project

<!-- .csproj file -->
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

</Project>

Dealing with Nullable References

string? nullableName = GetNameFromDatabase();

if (nullableName != null)
{
    Console.WriteLine("Hello, " + nullableName.ToUpper());
}
else
{
    Console.WriteLine("Name not found.");
}

Using Null-Conditional and Null-Coalescing Operators

string? nullableName = GetNameFromDatabase();

// Null-conditional operator
string? upperCaseName = nullableName?.ToUpper();

// Null-coalescing operator
string displayName = nullableName ?? "Guest";

Console.WriteLine($"Upper Case Name: {upperCaseName ?? "(Null)"}");
Console.WriteLine($"Display Name: {displayName}");

Attributes for Fine-Grained Control

public class MyClass
{
    // Indicates that the method will always return a non-null value
    [return: NotNull]
    public string GetName() => "Example";

    // Indicates that the parameter cannot be null
    public void ProcessName([NotNull] string name)
    {
        Console.WriteLine(name.ToUpper());
    }

    //Indicates that the parameter can be null
     public void ProcessNullableName([AllowNull] string? name)
    {

    }
}

Concepts Behind the Snippet

Real-Life Use Case Section

Best Practices

• Enable NRTs in all new projects.
• Carefully analyze existing code and migrate it to use NRTs.
• Use nullable reference types (string?) only when a value is truly optional or could be null.
• Always check for null when working with nullable reference types using if statements, the null-conditional operator (?.), or the null-coalescing operator (??).
• Use attributes like [AllowNull], [DisallowNull], [NotNull], and [MaybeNull] to provide more precise nullability information.
• Consider using code analysis tools to help identify potential null reference issues.

Interview Tip

When to Use Them

Memory Footprint

Alternatives

Pros

• Improved null safety: NRTs help prevent null reference exceptions at compile time.
• Enhanced code quality: NRTs encourage developers to write more robust and maintainable code.
• Reduced runtime errors: By catching potential null reference issues early, NRTs can significantly reduce runtime errors.
• Better code readability: NRTs make it clearer which references can be null and which cannot.
• Compiler assistance: The compiler provides warnings and errors to help you identify and fix potential null reference issues.

Cons

• Migration effort: Migrating existing code to use NRTs can require significant effort, especially in large projects.
• Increased code complexity: Dealing with nullable reference types can add some complexity to your code.
• Potential for false positives: The compiler's nullability analysis is not perfect and may sometimes produce false positive warnings.
• Learning curve: Developers need to learn how to use NRTs effectively.
• Requires C# 8.0 or later: Older versions of C# do not support NRTs.