மதிப்பு வகைகள் (value types) மற்றும் குறிப்பு வகைகள் (reference types) இடையே என்ன வேறுபாடு உள்ளது?

Question

Accepted Answer

C# வகைகள் இரண்டு அடிப்படை வகுப்புகளாக பிரிக்கப்படுகின்றன: **மதிப்பு வகைகள்** (தரவை நேரடியாக சேமிக்கும்) மற்றும் **குறிப்பு வகைகள்** (heap-இல் உள்ள தரவுக்கான குறிப்பு/சுட்டியை சேமிக்கும்). அவை எவ்வாறு சேமிக்கப்படுகின்றன, நகலெடுக்கப்படுகின்றன, மற்றும் ஒப்பிடப்படுகின்றன என்பதில் வேறுபடுகின்றன — இது மொழி முழுவதும் நடத்தையை பாதிக்கும் ஒரு முக்கியமான வேறுபாடு.

## இரண்டு வகுப்புகள்

```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, primitives int/double போன்றவை, enums) மதிப்பால் நகலெடுக்கப்படுகின்றன (சுயாதீனமான நகல்கள்) மற்றும் **குறிப்பு வகைகள்** (classes, arrays, strings) குறிப்பால் நகலெடுக்கப்படுகின்றன (இரண்டு பெயர்களும் ஒரே பொருளைச் சுட்டிக்காட்டுகின்றன) என்பதைப் புரிந்துகொள்வது தரவு எவ்வாறு நடந்துகொள்கிறது என்பதை கணிக்க முக்கியமாகும்: மதிப்பு-வகை நকலை மாற்றுவது அசலை பாதிக்காது, ஆனால் பகிரப்பட்ட குறிப்பு-வகை பொருளை பிறழ்வது அதற்கு அனைத்து குறிப்புகளையும் பாதிக்கிறது (ஆச்சரியமான பிழைகளின் பொதுவான மூலம்).

இந்த வேறுபாடு **சமத்வம்** (`==` மதிப்பு வகைகளுக்கு மதிப்புகளை ஒப்பிடுகிறது ஆனால் குறிப்பு வகைகளுக்கு இயல்பாக குறிப்பு அடையாளத்தை ஒப்பிடுகிறது), **முறை வாதங்கள்** (மதிப்பு வகைகள் நகல்களாக அனுப்பப்படுகின்றன, குறிப்பு வகைகளின் குறிப்புகள் மதிப்பால் அனுப்பப்படுகின்றன — எனவே முறைகள் ஒரு அனுப்பப்பட்ட பொருளை பிறழ்வலாம் ஆனால் ஒரு அனுப்பப்பட்ட int இல்லை), மற்றும் **nullability** (குறிப்பு வகைகளை மட்டுமே null ஆக இருக்க முடியும், `?` உடன் ஒரு மதிப்பு வகையை nullable ஆக்கிய இடங்களைத் தவிர) பாதிக்கிறது.

வகைகள் எவை மதிப்பு மற்றும் குறிப்பு என்பதையும் விளைந்த நகல், ஒப்பீடு, மற்றும் பிறழ்வு உள்ளளவியலையும் புரிந்துகொள்வது சரியான C# எழுத என்பதற்கு அடிப்படையாகும் மற்றும் மொழியின் மிக பொதுவான கருத்தியல் பிழைகளைத் தவிர்க்கிறது — இது தரவு ஒரு நிரலின் மூலம் எவ்வாறு பாய்கிறது என்பதற்கு அடிப்படையாகும் மற்றும் நடைமுறை தலைப்பு தர்க்கிற ஒரு ஆய்வு என்பது ஏனெனில் இது ஒரு டெவலப்பர் உண்மையாக C#ன் வகை முறைமையைப் புரிந்துகொண்டாரா என்பதை வெளிப்படுத்துகிறது.