విలువ రకాలు మరియు సూచన రకాలు మధ్య వ్యత్యాసం ఏమిటి?

Question

Accepted Answer

C# రకాలు రెండు ప్రాథమిక వర్గాలుగా విభజించబడ్డాయి: **విలువ రకాలు** (డేటాను నేరుగా నిల్వ చేస్తాయి) మరియు **సూచన రకాలు** (హీప్‌లోని డేటాకు సూచన/పాయింటర్‌ను నిల్వ చేస్తాయి). అవి ఎలా నిల్వ చేయబడతాయి, కాపీ చేయబడతాయి మరియు పోల్చబడతాయి - ఇది భాష అంతటా ప్రవర్తనను ప్రభావితం చేసే నిర్ణయాత్మక వ్యత్యాసం.

## రెండు వర్గాలు

```text
Value types     → struct, int, double, bool, char, enum, DateTime, decimal
                  Stored INLINE (stack for locals); copied BY VALUE.
Reference types → class, string, array, object, interface, delegate
                  Variable holds a REFERENCE to data on the heap; copied BY REFERENCE.
```

## కీ తేడా: కాపీ సెమాంటిక్‌లు

```csharp
// VALUE type — assignment COPIES the value (independent)
int a = 5;
int b = a;      // b is a COPY
b = 10;         // a is still 5

struct Point { public int X; }
Point p1 = new() { X = 1 };
Point p2 = p1;  // COPIES the whole struct
p2.X = 99;      // p1.X is still 1

// REFERENCE type — assignment copies the REFERENCE (both point to the SAME object)
class Box { public int Value; }
Box box1 = new() { Value = 1 };
Box box2 = box1;   // both reference the SAME Box
box2.Value = 99;   // box1.Value is now 99 too!
```

విలువ రకాన్ని కేటాయించడం డేటాను కాపీ చేస్తుంది (స్వతంత్రమైనది); సూచన రకాన్ని కేటాయించడం సూచనను కాపీ చేస్తుంది (రెండు పేర్లు ఒకే ఆబ్జెక్ట్‌ను సూచిస్తాయి, కాబట్టి ఒకటి ద్వారా మార్పు చేస్తే మరొకటి ప్రభావితమవుతుంది).

## పోలిక మరియు పద్ధతులకు ప్రసారం

```csharp
// == compares VALUES for value types, REFERENCES (identity) for reference types
string s1 = "hi"; // (string is special — == compares content)
Box b1 = new(), b2 = new();
b1 == b2;   // false — different objects (reference equality by default)

// methods get a COPY of value types, the reference (by value) for reference types
void Modify(Box b) { b.Value = 100; }   // affects the caller's object
void Modify(int x) { x = 100; }           // does NOT affect the caller's int
```

## null

```text
Reference types can be null (no object). Value types CANNOT be null
(unless made nullable: int? — a Nullable<int>).
```

## ఇది ఎందుకు ముఖ్యమైనది

విలువ-వర్సెస్-సూచన వ్యత్యాసం C#లో అత్యంత ప్రాథమిక భావనల్లో ఒకటి, మరియు ఇది విస్తృత శ్రేణి ప్రవర్తనలు మరియు బగ్‌లను వివరిస్తుంది - ఇది అপরిహార్య జ్ఞానం చేస్తుంది.

**విలువ రకాలు** (structs, int/double వంటి ప్రిమిటివ్‌లు, enums) విలువ ద్వారా కాపీ చేయబడతాయి (స్వతంత్ర కాపీలు) అయితే **సూచన రకాలు** (classes, arrays, strings) సూచన ద్వారా కాపీ చేయబడతాయని అర్థం చేసుకోవడం (రెండు పేర్లు ఒకే ఆబ్జెక్ట్‌ను సూచిస్తాయి) డేటా ఎలా ప్రవర్తిస్తుందో ఊహించడానికి కీలకం: విలువ-రకం కాపీని సవరించడం అసలు విషయాన్ని ప్రభావితం చేయదు, కానీ భాగస్వామ్య సూచన-రకం ఆబ్జెక్ట్‌ను మార్చడం దానికి సంబంధించిన అన్ని సూచనలను ప్రభావితం చేస్తుంది (ఆశ్చర్యకరమైన బగ్‌ల యొక్క సాధారణ మూలం).

ఈ వ్యత్యాసం **సమానత్వం** (`==` విలువ రకాలకు విలువలను పోల్చుకుంటుంది కానీ డిఫాల్ట్‌గా సూచన రకాలకు సూచన గుర్తింపు), **పద్ధతి ఆర్గ్యుమెంట్‌లు** (విలువ రకాలు కాపీలుగా ఆర్గ్యుమెంట్‌లుగా ఆమోదించబడతాయి, సూచన రకాల సూచనలు విలువ ద్వారా ఆమోదించబడతాయి — కాబట్టి పద్ధతులు ఆమోదించిన ఆబ్జెక్ట్‌ను మార్చగలవు కానీ ఆమోదించిన int కాదు), మరియు **nullability** (విలువ రకం `?` తో నల్‌లేబల్‌ చేయకపోతే సూచన రకాలు మాత్రమే null కావచ్చు)ను కూడా ప్రభావితం చేస్తుంది.

రకాలు విలువ వర్సెస్ సూచన మరియు ఫలితంగా కాపీ, పోలిక మరియు ఉత్పరివర్తన సెమాంటిక్‌ల గురించి అర్థం చేసుకోవడం సరైన C# వ్రాయడానికి మరియు భాష యొక్క అత్యంత సాధారణ సంభావిత ఆపదలను నివారించడానికి ఫाউండేషనల్‌ — ఇది ప్రోగ్రామ్ ద్వారా డేటా ఎలా ప్రవహిస్తుందో అండర్‌పిన్‌ చేస్తుంది మరియు ఒక డెవలపర్ నిజంగా C#'s రకం వ్యవస్థను అర్థం చేసుకున్నారో లేదో బహిర్గతం చేస్తుంది కాబట్టి ఎంటర్‌వ్యూ విషయం ఎక్కువ.