Nullable reference types (NRTs) in C# 8 help catch NullReferenceException errors at compile time by making reference types non-nullable by default, requiring explicit declaration for nullability. NRTs must be enabled either in the .csproj file with enable or at the top of a .cs file using #nullable enable. Once enabled, variables like string name; are treated as non-null, while nullable ones must be declared as string? name;. The compiler warns if a potentially null value is used without checking, such as calling .Length on a string? variable. NRTs help in real-world cases like handling data from APIs or databases, collections with nullable elements, and optional parameters that accept null. Proper handling techniques include using null-conditional operators (?.), null-coalescing operators (??), explicit null checks, and attributes like NotNullIfNotNull. Ultimately, NRTs don’t remove nulls but enforce intentional null handling, resulting in safer, more predictable code.

Nullable reference types (NRTs) in C# 8 are a feature designed to help developers catch potential NullReferenceException errors at compile time instead of runtime. In earlier versions of C#, all reference types were nullable by default, meaning you could assign null to them without any warnings or errors. This often led to unexpected crashes when trying to access members on a null object.

With NRTs, reference types are non-nullable by default, and the compiler warns you if it detects that a variable might be null when you try to use it. This helps enforce better null handling practices and reduces bugs caused by unhandled null values.

Enabling Nullable Reference Types

To use NRTs, you need to opt into the feature. It’s not automatically enabled by default in all projects — especially older ones.

You can enable NRTs in one of two ways:

• In your .csproj file:

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

• At the top of a specific .cs file:

  #nullable enable

Once enabled, the compiler starts analyzing your code for possible null usage on non-nullable reference types.

Understanding Nullability Annotations

When NRTs are enabled, string declarations like string name; mean name should never be null. If you want to allow null, you must explicitly declare it as string? name;.

This distinction allows the compiler to track where nulls are expected and where they aren't.

For example:

string message = GetMessage(); // Compiler may warn here if GetMessage can return null
Console.WriteLine(message.Length); // Warning: Possible dereference of a null reference

If GetMessage() is declared to return string?, the compiler will warn you before accessing .Length, because message could be null.

This makes it easier to spot places where you forgot to handle null cases.

Common Scenarios Where NRTs Help

There are several real-world situations where NRTs help prevent NullReferenceException:

• Data from external sources
  Like APIs or databases, which may return null unexpectedly. Declaring such results as string? forces you to check before using them.

• Collections with possible null elements
  For example, List<string></string> tells you some items in the list might be null, so you should check each one before use.

• Optional method parameters with null defaults
  When using optional parameters like void Log(string? message = null), marking the parameter as nullable reminds callers that null is a valid input.

By making nullability part of the type system, NRTs encourage developers to write safer code without relying solely on documentation or runtime checks.

How to Handle Null Cases Properly

Just because NRTs flag potential issues doesn’t mean you’re done — you still need to handle those cases correctly. Here are a few common techniques:

• Use null-conditional operators: person?.Name
• Use null-coalescing operators: name ?? "default"
• Add explicit null checks: if (value == null) throw new ArgumentNullException(...)
• Use NotNullIfNotNull and other attributes to help the compiler understand more complex logic

These patterns become second nature once you start working with NRTs regularly.

Basically, nullable reference types don’t magically eliminate nulls — they just make you think about where they can appear and how to handle them safely. It’s a small shift in mindset that pays off in fewer crashes and more predictable code.

The above is the detailed content of What are nullable reference types (NRTs) in C# 8 , and how do they help prevent NullReferenceException?. For more information, please follow other related articles on the PHP Chinese website!