મૂલ્ય પ્રકાર અને સંદર્ભ પ્રકાર વચ્ચે શું તફાવત છે?

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# માં સૌથી મૌલિક ખ્યાલોમાંનો એક છે, અને તે વ્યાપક શ્રેણીની વર્તણૂક અને બગ્સને સમજાવે છે — તેને આવશ્યક જ્ञાન બનાવે છે.

જાણવું કે **મૂલ્ય પ્રકાર** (સ્ટ્રક્ટ્સ, પ્રાથમિક પ્રકાર જેમ કે int/double, enums) મૂલ્ય દ્વારા નકલ કરવામાં આવે છે (સ્વતંત્ર નકલો) જ્યારે **સંદર્ભ પ્રકાર** (વર્ગો, આરેઓ, સ્ટ્રિંગ્સ) સંદર્ભ દ્વારા નકલ કરવામાં આવે છે (બંને નામો એક જ વસ્તુ તરફ નિર્દેશ કરે છે) ડેટા કેવી રીતે વર્તે છે તેની આગાહી કરવા માટે જરૂરી છે: મૂલ્ય-પ્રકારની નકલને સંશોધિત કરવું મૂળને અસર કરતું નથી, પરંતુ શેર્ડ સંદર્ભ-પ્રકારની વસ્તુમાં ફેરફાર તેની તમામ સંદર્ભોને અસર કરે છે (આશ્ચર્યજનક બગ્સનો સામાન્ય સ્ત્રોત).

યह તફાવત **સમાનતા** પણ અસર કરે છે (`==` મૂલ્ય પ્રકાર માટે મૂલ્યોની સરખામણી કરે છે પણ ડિફોલ્ટ દ્વારા સંદર્ભ પ્રકાર માટે સંદર્ભ ઓળખ કરે છે), **પદ્ધતિ દલીલો** (મૂલ્ય પ્રકાર નકલો તરીકે પસાર કરવામાં આવે છે, સંદર્ભ પ્રકારના સંદર્ભો મૂલ્ય દ્વારા પસાર કરવામાં આવે છે — તેથી પદ્ધતિઓ પસાર કરવામાં આવેલ વસ્તુમાં તમામ કરી શકે છે પણ પસાર કરવામાં આવેલ int નહીં), અને **નલેબિલિટી** (માત્ર સંદર્ભ પ્રકાર null હોઈ શકે છે, સિવાય કે મૂલ્ય પ્રકાર `?` સાથે નલેબલ બનાવવામાં આવે છે).

કયા પ્રકારો મૂલ્ય વર્સ સંદર્ભ છે અને પરિણામી નકલ, સરખામણી અને તમામ શાસ્ત્ર સમજવું સાચી C# લખવા અને ભાષાના સૌથી સામાન્ય ખ્યાલાત્મક મુશ્કેલીઓને ટાળવા માટે અનિવાર્ય છે — તે પ્રોગ્રામ દ્વારા ડેટા કેવી રીતે વહે છે તેને અંતર્ગત કરે છે અને તે ઘણીવાર साક્ષાત્કાર વિષય છે કારણ કે તે આવતું કે ડેવલપર ખરેખર C# ના પ્રકાર સિસ્ટમને સમજે છે તે આવતું છે.