C# razlikuje tipove koji mogu biti od onih koji ne mogu. () omogućavaju vrijednosnim tipovima da sadrže null, (svojstvo kompajlera) pomažu u pronalaženju null bugova, a (, , ) čine rad s mogućim null vrijednostima čistim i sigurnim — rješavajući pervasivni problem null referencije.
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
Vrijednosni tipovi normalno ne mogu biti null, ali int? (Nullable<int>) to dozvoljava — uobičajeno za opcijske/nedostajuće podatke (npr. nullable stupac baze podataka).
#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)
}
S nullable referentnim tipovima omogućenim, kompajler prati koje reference mogu biti null (string?) nasuprot onih koji nisu (string) i upozora kada biste mogli dereferencirati null — hvatajući NullReferenceException bugove tijekom kompajliranja. Ovo je glavno moderno svojstvo sigurnosti u C#-u.
// ?. 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
Operator null-uvjetnog pristupa (?.) sigurno pristupa članovima mogućih null vrijednosti (vraćajući null umjesto bacanja iznimke), a ?? pruža podrazumevane vrijednosti — zajedno čineći rukovanje null vrijednostima čistim i sigurnim.
Rukovanje null vrijednostima je jedan od najvažnijih aspekata pisanja robusnog C#-a, budući da je NullReferenceException ("greška od milijardu dolara") jedna od najčešćih runtime grešaka — a nullable tipovi i operatori C#-a direktno se bave njom, čineći ih bitnim znanjem. Nullable vrijednosni tipovi (int?) su praktički neophodni za predstavljanje opcijskih/nedostajućih podataka (nullable polja baze podataka, opcijske vrijednosti).
Svojstvo nullable referentnih tipova (sada standardno u modernim .NET projektima) je značajno poboljšanje sigurnosti: jer kompajler prati i upozora na moguće null dereferencije, hvata cijelu klasu null bugova tijekom kompajliranja umjesto kao runtime padove — značajna prednost pouzdanosti koju biste trebali razumjeti i poštovati.
Operatori za rukovanje null vrijednostima su alati za svakodnevnu upotrebu koji čine rad s mogućim null vrijednostima čistim i sigurnim: operator null-uvjetnog pristupa (?.) sigurno navigira mogućim null lancima (vraćajući null umjesto bacanja), ??/??= pružaju podrazumevane vrijednosti sažeto, a ! potvrduje non-null (trebat će se koristiti oprezno).
Razumijevanje nullable vrijednosnih tipova, svojstva sigurnosti nullable referentnih tipova i operatora za rukovanje null vrijednostima (?., ??, !) je važno za pisanje null-sigurnog, robusnog C#-a koji izbjegava pervasivnu NullReferenceException — čest, praktički-kritičan problem.
Budući da su null-povezani bugovi toliko česti i C# pruža moćne alate (osobito provjeru null vrijednosti tijekom kompajliranja) za njihovo sprječavanje, savladavanje nullable tipova i null operatora je temeljno, nezaobilazno znanje za pisanje pouzdanog modernog C#-a.