value और reference types में क्या अंतर है?

Question

Accepted Answer

C# types दो मूलभूत श्रेणियों में आते हैं: **value types** (data को सीधे store करते हैं) और **reference types** (heap पर मौजूद data का reference/pointer store करते हैं)। ये इस बात में भिन्न होते हैं कि इन्हें कैसे store, copy और compare किया जाता है — एक महत्वपूर्ण अंतर जो पूरी भाषा में behavior को प्रभावित करता है।

## दो श्रेणियाँ

```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.
```

## मुख्य अंतर: copy semantics

```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!
```

एक value type को assign करने पर data copy होता है (independent); एक reference type को assign करने पर reference copy होता है (दोनों नाम एक ही object को point करते हैं, इसलिए एक के through mutate करने से दूसरा भी प्रभावित होता है)।

## Comparison और methods में passing

```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>).
```

## यह क्यों महत्वपूर्ण है

value-बनाम-reference का अंतर C# की सबसे मूलभूत अवधारणाओं में से एक है, और यह behaviors व bugs की एक विस्तृत श्रृंखला की व्याख्या करता है — जिससे यह आवश्यक ज्ञान बन जाता है।

यह समझना कि **value types** (structs, int/double जैसे primitives, enums) value द्वारा copy होते हैं (independent copies) जबकि **reference types** (classes, arrays, strings) reference द्वारा copy होते हैं (दोनों नाम एक ही object को point करते हैं), यह अनुमान लगाने के लिए महत्वपूर्ण है कि data कैसा व्यवहार करेगा: एक value-type copy को modify करने से original प्रभावित नहीं होता, लेकिन एक shared reference-type object को mutate करने से उसके सभी references प्रभावित होते हैं (आश्चर्यजनक bugs का एक सामान्य स्रोत)।

यह अंतर **equality** (`==` value types के लिए values की तुलना करता है लेकिन reference types के लिए default रूप से reference identity की), **method arguments** (value types copies के रूप में pass होते हैं, reference types के references value द्वारा pass होते हैं — इसलिए methods एक passed object को mutate कर सकते हैं लेकिन एक passed int को नहीं), और **nullability** (केवल reference types null हो सकते हैं, जब तक कि किसी value type को `?` के साथ nullable न बनाया जाए) को भी प्रभावित करता है।

यह समझना कि कौन से types value हैं बनाम reference और उससे उत्पन्न copy, comparison व mutation semantics, सही C# लिखने और भाषा की सबसे सामान्य वैचारिक गलतियों से बचने के लिए आधारभूत है — यह इस बात को रेखांकित करता है कि data एक program में कैसे प्रवाहित होता है और यह एक बार-बार पूछा जाने वाला interview विषय है क्योंकि यह ठीक-ठीक यह प्रकट करता है कि क्या एक developer वास्तव में C# के type system को समझता है।