C# unterscheidet zwischen Typen, die sein können, und solchen, die es nicht können. () ermöglichen es Werttypen, null zu halten, (ein Compiler-Feature) helfen dabei, Null-Bugs zu erkennen, und (, , ) ermöglichen einen sauberen und sicheren Umgang mit möglicherweise Null-Werten — und adressieren damit das weit verbreitete Null-Referenz-Problem.
nullint??.??!int x = 5; // a value type — CANNOT be null
int? y = null; // int? = Nullable<int> — CAN be null
if (y.HasValue) { int val = y.Value; } // check + access
int z = y ?? 0; // default if null
Werttypen können normalerweise nicht null sein, aber int? (Nullable<int>) ermöglicht es — üblich für optionale/fehlende Daten (z. B. eine Nullable-Datenbankspalte).
#nullable enable // (on by default in modern projects)
string name = null; // ⚠️ warning — string is non-nullable by default now
string? maybe = null; // ✅ string? explicitly allows null
void Use(string? s) {
Console.WriteLine(s.Length); // ⚠️ warning — s might be null (must check first)
}
Wenn Nullable-Referenztypen aktiviert sind, verfolgt der Compiler, welche Referenzen null sein können (string?) und welche nicht (string), und warnt, wenn Sie möglicherweise null dereferenzieren — und fängt damit NullReferenceException-Bugs zur Compile-Zeit ab. Dies ist ein wichtiges modernes C#-Sicherheits-Feature.
// ?. null-conditional — short-circuits to null instead of throwing
int? len = user?.Name?.Length; // null if user or Name is null (no exception)
user?.DoSomething(); // only calls if user isn't null
// ?? null-coalescing — provide a default
string name = input ?? "Anonymous";
name ??= "fallback"; // assign if currently null
// ! null-forgiving — assert non-null (suppress the warning; use carefully)
string definitelyNotNull = maybe!; // "I know it's not null" — no runtime check
Der Null-Conditional-Operator (?.) greifen sicher auf Members möglicherweise Null-Werte zu (gibt null zurück, statt eine Exception zu werfen), und ?? bietet Standards — zusammen wird damit Null-Handling sauber und sicher.
Null-Handling ist einer der wichtigsten Aspekte beim Schreiben von robustem C#, da NullReferenceException ("der milliardenschwere Fehler") einer der häufigsten Laufzeitfehler ist — und C#s Nullable-Typen und Operatoren adressieren dies direkt, weshalb sie essentielles Wissen sind. Nullable-Werttypen (int?) sind praktisch notwendig, um optionale/fehlende Daten darzustellen (Nullable-Datenbankfelder, optionale Werte).
Das Nullable-Referenztypen-Feature (jetzt standardmäßig in modernen .NET-Projekten aktiviert) ist eine große Sicherheitsverbesserung: Indem der Compiler mögliche Null-Dereferenzierungen verfolgt und vor ihnen warnt, erkennt er eine ganze Klasse von Null-Bugs zur Compile-Zeit, statt als Runtime-Crashes — ein großer Zuverlässigkeitsvorteil, den Sie verstehen und beachten sollten.
Die Null-Handling-Operatoren sind alltägliche Tools, die das Arbeiten mit möglicherweise Null-Werten sauber und sicher machen: Der Null-Conditional-Operator (?.) navigiert sicher durch möglicherweise Null-Ketten (gibt null zurück, statt eine Exception zu werfen), ??/??= bieten prägnant Defaults, und ! behauptet Non-Null (sollte vorsichtig verwendet werden).
Das Verstehen von Nullable-Werttypen, dem Nullable-Referenztypen-Sicherheits-Feature und den Null-Handling-Operatoren (?., ??, !) ist wichtig für das Schreiben von Null-sicheren, robusten C#, das die weit verbreitete NullReferenceException vermeidet — ein häufiges, praktisch kritisches Anliegen.
Da Null-bezogene Bugs so häufig sind und C# starke Tools bietet (besonders Compile-Zeit-Null-Checking), um sie zu verhindern, ist das Beherrschen von Nullable-Typen und Null-Operatoren grundlegendes, unumgängliches Wissen für das Schreiben von zuverlässigen modernen C#.