Aktivierung und Konfiguration von Nullable Reference Types (NRT) im Projekt

1. Einführung

Warum muss man NRT extra aktivieren?

Nullable Reference Types (NRT) sind nicht einfach nur syntaktischer Zucker, sondern ein richtig hilfreiches Tool vom Compiler, um Fehler mit null zu vermeiden. Aus historischen Gründen ist dieser Modus aber nicht in allen alten Projekten standardmäßig aktiv – damit nichts kaputtgeht. Wenn du ein neues Projekt mit den aktuellen .NET-Versionen erstellst (zum Beispiel .NET 7, 8 oder 9), ist NRT meistens schon automatisch an. Aber wenn das Projekt älter ist oder du das manuell steuern willst, musst du das explizit einstellen.

Was macht der Nullable Reference Types Modus?

Wenn dieser Modus aktiv ist, checkt der Compiler, welche Referenzvariablen null sein können und welche nicht. Er beeinflusst nicht die Programmausführung, aber er schmeißt ordentlich Warnungen raus, wenn er einen möglichen Fehler sieht. Das ist ein super Weg, um zuverlässigen, verständlichen und stabilen Code zu schreiben.

Wie finde ich raus, ob NRT aktiviert ist?

Wenn du ein neues .NET 6 oder neueres Projekt hast, ist NRT wahrscheinlich schon an. Aber sicher ist sicher – lass uns das checken!

• Öffne die Projektdatei. Das ist meistens die Datei mit der Endung .csproj.
• Such nach der Einstellung <Nullable> oder füge sie im ersten <PropertyGroup>-Tag hinzu.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

Wenn da steht <Nullable>disable</Nullable>, ist die NRT-Kontrolle aus.

2. Wie aktiviere ich den NRT-Modus

Über .csproj – für das ganze Projekt

1. Öffne (oder erstelle) die .csproj-Datei.
2. Füge im <PropertyGroup>-Block die folgende Zeile hinzu oder ändere sie:

<Nullable>enable</Nullable>

Jetzt passt der Compiler auf alle .cs-Dateien im Projekt auf und meckert bei potenziell gefährlichen null-Zugriffen.

Warum macht man das?
Weil das eine globale Einstellung ist. Ab jetzt gilt für das ganze Projekt: null steht unter Verdacht, und Nachlässigkeit hat keine Chance mehr!

Nur für einzelne Dateien oder Codeabschnitte

Wenn du noch nicht bereit bist, den strengen Modus fürs ganze Projekt zu aktivieren, kannst du erstmal mit einzelnen Dateien üben. Dafür gibt’s Präprozessor-Direktiven:

#nullable enable
string? wert = null; // Hier ist die Analyse an

#nullable disable
string altWert = null; // Und hier – schon wieder aus

#nullable restore

• #nullable enable – aktiviert die Prüfung bis zum Ende der Datei.
• #nullable disable – schaltet sie aus.
• #nullable restore – stellt die Einstellungen aus .csproj oder externer Datei wieder her.

Das ist praktisch: Du kannst die strenge Kontrolle in neuen Modulen aktivieren, ohne alten, unsauberen Code anzufassen.

Was kann man noch bei <Nullable> angeben?

enable

disable

warnings

annotations

restore

Meistens nimmt man enable oder disable.

3. Demo am Beispiel

Vor der Aktivierung von NRT

// Alter Modus, NRT ist aus
string s = null; // Keine Beschwerden

Console.WriteLine(s.Length); // Gefährlich! Mögliches NullReferenceException

Nach der Aktivierung von NRT

// Neuer Modus, NRT ist an
string s = null; // Warnung: mögliches null-Zuweisung
Console.WriteLine(s.Length); // Warnung: möglicher Zugriff auf null

Jetzt markiert die IDE potenzielle Probleme und der Compiler warnt: Dereference of a possibly null reference. (CS8602)

Wie behebt man das?

string? s = null;

if (s != null)
{
    Console.WriteLine(s.Length);
}

So zeigst du explizit: Diese Variable kann null sein, und der Compiler ist zufrieden.

4. Was tun, wenn das Projekt "oldschool" geschrieben ist?

Viele Projekte wurden damals geschrieben, als null quasi in jeder Referenzvariable steckte. Wenn du NRT aktivierst, ist das wie ein strenger Prüfer, der jede potenzielle Gefahr meldet.

Und wenn es zu viele Warnungen gibt?

Keine Panik – das sind keine Fehler, sondern nur Hinweise. Das Programm lässt sich trotzdem kompilieren.

• Du kannst NRT erstmal nur in neuen Dateien aktivieren.
• Bring den Code nach und nach in Ordnung: Füge ? hinzu, prüfe auf null, nutze ! (dazu später mehr).
• Denk dran: Je sauberer du mit null umgehst, desto weniger Stress hast du später.

Rückwärtskompatibilität und externe Bibliotheken

• Das Aktivieren von NRT ändert nichts am Verhalten zur Laufzeit, sondern fügt nur Analyse beim Kompilieren hinzu.
• Alter Code kann erstmal viele Warnungen ausspucken.
• Wenn du Bibliotheken ohne NRT-Annotationen nutzt, geht der Compiler auf Nummer sicher und nimmt an, dass alles null sein könnte.