C# కలిగి ఉండే రకాలను వాటిలో ఉండని రకాలకు భిన్నంగా వేరుచేస్తుంది. () value రకాలకు null ఆనుకోవడానికి అనుమతిస్తుంది, (compiler feature) null బగ్లను పట్టుకోవడంలో సహాయపడతాయి, మరియు (, , ) సంభవనీయ-null విలువలతో పని చేయడం శుభ్రమైన మరియు సురక్షితమైన విధానం — విస్తృతమైన null-reference సమస్యను పరిష్కరిస్తుంది.\n\n## Nullable value types (int?)\n\n```csharp int x = 5; // a value type — CANNOT be null int? y = null; // int? = Nullable<int> — CAN be null
nullint??.??!if (y.HasValue) { int val = y.Value; } // check + access
int z = y ?? 0; // default if null
\n\nValue రకాలు సాధారణంగా null కలిగి ఉండలేవు, కానీ `int?` (`Nullable<int>`) దీన్ని అనుమతిస్తుంది — ఐచ్ఛిక/విలువ లేని డేటా కోసం సాధారణం (ఉదా. nullable డేటాబేస్ కాలమ్).\n\n## Nullable reference types (safety feature)\n\ncsharp
#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)
}
\n\n**Nullable reference types** చేతనం చేయబడినప్పుడు, compiler ఏ references null కలిగి ఉండవచ్చు (`string?`) vs కలిగి ఉండవు (`string`) అని ట్రాక్ చేస్తుంది మరియు మీరు null dereference చేయవచ్చు అయిన చోటికి **హెచ్చరిస్తుంది** — `NullReferenceException` బగ్లను compile time వద్ద పట్టుకుంటుంది. ఇది ఆధునిక C# safety feature.\n\n## Null-handling operators\n\ncsharp
// ?. 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
```\n\nNull-conditional operator (?.) సంభవనీయ-null విలువల సభ్యులను సురక్షితంగా యాక్సెస్ చేస్తుంది (throw చేయడానికి బదులుగా null తిరిగి ఇస్తుంది), మరియు ?? డిఫాల్ట్లను అందిస్తుంది — కలిసి null handling శుభ్రమైన మరియు సురక్షితమైన విధానం చేస్తుంది.\n\n## ఇది ఎందుకు ముఖ్యమైనది\n\nNull handling అనేది robust C# వ్రాయడానికి అత్యంత ముఖ్యమైన అంశాలలో ఒకటి, ఎందుకంటే NullReferenceException ("బిలియన్ డాలర్ల తప్పు") అత్యంత సాధారణ runtime errors లో ఒకటి — మరియు C#'s nullable types మరియు operators దీన్ని నేరుగా సంబోధిస్తాయి, వాటిని ముఖ్య జ్ఞానం చేస్తాయి. Nullable value types (int?) ఐచ్ఛిక/విలువ లేని డేటాను సూచించటానికి ఆచరణాత్మకంగా అవసరం (nullable డేటాబేస్ ఫీల్డ్లు, ఐచ్ఛిక విలువలు).\n\nNullable reference types feature (ఇప్పుడు ఆధునిక .NET ప్రాజెక్ట్లలో డిఫాల్ట్గా ఆన్లో ఉంది) ఎక్కువ safety సుధారణ: compiler సంభవనీయ null dereferences ను ట్రాక్ చేసి హెచ్చరించటం ద్వారా, ఇది null బగ్ల యొక్క పూర్తి class కు runtime crashes కు బదులుగా compile time వద్ద పట్టుకుంటుంది — ఒక ముఖ్యమైన reliability లాభం మీరు అర్థం చేసుకోవాలి మరియు పాటించాలి.\n\nNull-handling operators రోజువారీ సాధనాలు ఇవి సంభవనీయ-null విలువలతో పని చేయడం శుభ్రమైన మరియు సురక్షితమైన విధానం చేస్తాయి: null-conditional operator (?.) సంభవనీయ-null chains కు సురక్షితంగా నావిగేట్ చేస్తుంది (throw చేయడానికి బదులుగా null తిరిగి ఇస్తుంది), ??/??= డిఫాల్ట్లను సంక్షిప్తంగా అందిస్తాయి, మరియు ! non-null కు నిశ్చితం చేస్తుంది (జాగ్రత్తగా ఉపయోగించటానికి).\n\nNullable value types, nullable-reference-types safety feature, మరియు null-handling operators (?., ??, !) అర్థం చేసుకోవడం null-safe, robust C# వ్రాయడం కోసం ముఖ్యమైనది ఇది విస్తృతమైన NullReferenceException — ఒక సాధారణ, ఆచరణాత్మకంగా-క్లిష్టమైన సమస్యను నివారిస్తుంది.\n\nNull-సంబంధిత బగ్లు చాలా సాధారణం అయినందున మరియు C# వాటిని నివారించటానికి బలమైన సాధనాలను అందిస్తుంది (ప్రత్యేకించి compile-time null checking), nullable types మరియు null operators ని నైపుణ్యం చేసుకోవడం మూల, తప్పక-తెలుసుకోవాల్సిన జ్ఞానం robust ఆధునిక C# వ్రాయటానికి.