C# એવા types ને અલગ કરે છે જે હોઈ શકે તેમાંથી જે ન હોઈ શકે. () value types ને null રાખવાની છૂટ આપે છે, (એક compiler feature) null bugs ને પકડવામાં મદદ કરે છે, અને (, , ) possibly-null values સાથે કામ કરવાને સ્વચ્છ અને સુરક્ષિત બનાવે છે — pervasive null-reference 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
Value types સામાન્ય રીતે null ન હોઈ શકે, પણ int? (Nullable<int>) તેને મંજૂરી આપે છે — optional/missing data માટે સામાન્ય (દા.ત. nullable database column).
#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)
}
nullable reference types સક્ષમ કરીને, compiler ટ્રેક કરે છે કે કયા references null હોઈ શકે (string?) વર્સેસ ન હોઈ શકે (string) અને જ્યારે તમે null ને dereference કરી શકો ત્યારે ચેતવણી આપે છે — NullReferenceException bugs ને compile time પર પકડે છે. આ એક મુખ્ય આધુનિક C# safety 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
null-conditional operator (?.) safely possibly-null values ના members ને access કરે છે (throwing ની જગાએ null return કરે છે), અને ?? defaults આપે છે — એક સાથે null handling ને સ્વચ્છ અને સુરક્ષિત બનાવે છે.
Null handling એ robust C# લખવાના સૌથી મહત્વના પાસાઓમાંનું એક છે, કારણ કે NullReferenceException ("the billion-dollar mistake") સૌથી સામાન્ય runtime errors માંનું એક છે — અને C#ના nullable types અને operators તેને સીધું સંબોધે છે, તેમને આવશ્યક જ્ઞાન બનાવે છે. Nullable value types (int?) optional/missing data (nullable database fields, optional values) ને represent કરવા માટે વ્યવહારીક રીતે જરૂરી છે.
nullable reference types feature (હવે આધુનિક .NET projects માં default ચાલુ છે) એક મુખ્ય safety improvement છે: compiler ને possible null dereferences ને ટ્રેક અને ચેતવણી આપવાથી, તે null bugs ના સંપૂર્ણ વર્ગને compile time પર પકડે છે runtime crashes ની જગાએ — એક નોંધપાત્ર reliability લાભ જે તમે સમજવું અને માનવું જોઈએ.
null-handling operators રોજિંદા સાધનો છે જે possibly-null values સાથે કામ કરવાને સ્વચ્છ અને સુરક્ષિત બનાવે છે: null-conditional operator (?.) safely possibly-null chains ને navigate કરે છે (throwing ની જગાએ null return કરે છે), ??/??= concisely defaults આપે છે, અને ! non-null ને assert કરે છે (સાવધાનીથી વાપરવું જોઈએ).
Nullable value types, nullable-reference-types safety feature, અને null-handling operators (?., ??, !) ને સમજવું null-safe, robust C# લખવા માટે મહત્વનું છે જે pervasive NullReferenceException ને avoid કરે છે — એક વારંવાર, વ્યવહારીક રીતે-critical concern.
Null-related bugs એટલી સામાન્ય છે અને C# strong tools (خાસ કરીને compile-time null checking) તેમને રોકવા માટે આપે છે, nullable types અને null operators માં mastery કરવું foundational, must-know knowledge છે reliable આધુનિક C# લખવા માટે.