C# skiljer mellan typer som kan vara och typer som inte kan det. () låter värdetyper innehålla null, (en kompilatorsfunktion) hjälper till att fånga null-buggar, och (, , ) gör arbetet med möjligtvis null-värden rent och säkert — och adresserar det genomgripande null-referensproblemet.
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
Värdetyper kan normalt inte vara null, men int? (Nullable<int>) tillåter det — vanligt för valfri/saknad data (t.ex. en nullable databaskolumn).
#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)
}
Med nullable referenstyper aktiverat spårar kompilatorn vilka referenser som kan vara null (string?) kontra inte (string) och varnar när du eventuellt kan dereferera null — och fångar NullReferenceException-buggar vid kompileringstid. Det här är en stor modern C#-säkerhetsfunktion.
// ?. 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
Null-conditional operatorn (?.) åtkomst medlemmar av möjligtvis null-värden på ett säkert sätt (returnerar null istället för att kasta undantag), och ?? tillhandahåller standardvärden — tillsammans gör de null-hantering rent och säker.
Null-hantering är en av de viktigaste aspekterna av att skriva robust C#, eftersom NullReferenceException ("billion-dollar-misstaget") är ett av de mest vanliga körningsfel — och C#:s nullable-typer och operatorer adresserar det direkt, vilket gör dem till väsentlig kunskap. Nullable värdetyper (int?) är praktiskt taget nödvändiga för att representera valfri/saknad data (nullable databasfält, valfria värden).
Nullable referenstyper-funktionen (nu på som standard i moderna .NET-projekt) är en stor säkerhetsforbättring: genom att kompilatorn spårar och varnar om möjliga null-derefereringar fångar den en hel klass av null-buggar vid kompileringstid istället för som körningsfel — en betydande tillförlitlighetsfördel som du bör förstå och respektera.
Null-hanteringsoperatorerna är vardagliga verktyg som gör arbetet med möjligtvis null-värden rent och säkert: null-conditional operatorn (?.) navigerar säkert genom möjligtvis null-kedjor (returnerar null istället för att kasta undantag), ??/??= tillhandahåller standardvärden koncist, och ! hävdar non-null (används försiktigt).
Att förstå nullable värdetyper, nullable-referenstyper-säkerhetsfunktionen och null-hanteringsoperatorerna (?., ??, !) är viktigt för att skriva null-säker, robust C# som undviker det genomgripande NullReferenceException-problemet — en ofta förekommande, praktiskt-kritisk angelägenhet.
Eftersom null-relaterade buggar är så vanliga och C# tillhandahåller starka verktyg (särskilt null-kontroll vid kompileringstid) för att förhindra dem, är det fundamentalt och måste-kunskap att bemästra nullable-typer och null-operatorer för att skriva pålitlig modern C#.