อะไรคือความแตกต่างระหว่าง value type และ reference type?

Question

Accepted Answer

ชนิดข้อมูลใน C# แบ่งออกเป็นสองประเภทพื้นฐาน ได้แก่ **value type** (เก็บข้อมูลโดยตรง) และ **reference type** (เก็บ reference/pointer ที่ชี้ไปยังข้อมูลบน 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.
```

## ความแตกต่างสำคัญ: 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 จะคัดลอกข้อมูล (เป็นอิสระต่อกัน) ส่วนการกำหนดค่า reference type จะคัดลอก reference (ทั้งสองชื่อชี้ไปยัง object เดียวกัน ดังนั้นการเปลี่ยนแปลงผ่านตัวหนึ่งจะส่งผลต่ออีกตัวด้วย)

## การเปรียบเทียบและการส่งเข้า method

```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# และอธิบายพฤติกรรมและบั๊กได้หลากหลายรูปแบบ จึงเป็นความรู้ที่จำเป็นต้องเข้าใจ

การเข้าใจว่า **value type** (struct, primitive อย่าง int/double, enum) ถูกคัดลอกแบบ by value (เป็นสำเนาที่อิสระต่อกัน) ขณะที่ **reference type** (class, array, string) ถูกคัดลอกแบบ by reference (ทั้งสองชื่อชี้ไปยัง object เดียวกัน) เป็นสิ่งสำคัญต่อการคาดเดาพฤติกรรมของข้อมูล นั่นคือ การแก้ไขสำเนาของ value type ไม่ส่งผลต่อค่าต้นฉบับ แต่การเปลี่ยนแปลง object แบบ reference type ที่ใช้ร่วมกันจะส่งผลต่อทุก reference ที่ชี้ไปยังมัน (ซึ่งเป็นแหล่งที่มาที่พบบ่อยของบั๊กที่น่าประหลาดใจ)

ความแตกต่างนี้ยังส่งผลต่อ **การเปรียบเทียบความเท่ากัน** (`==` เปรียบเทียบค่าสำหรับ value type แต่เปรียบเทียบ reference identity สำหรับ reference type โดยค่าเริ่มต้น), **อาร์กิวเมนต์ของ method** (value type ส่งเป็นสำเนา ส่วน reference ของ reference type ส่งแบบ by value ดังนั้น method สามารถเปลี่ยนแปลง object ที่ส่งเข้ามาได้แต่เปลี่ยน int ที่ส่งเข้ามาไม่ได้) และ **nullability** (มีเพียง reference type เท่านั้นที่เป็น null ได้ ยกเว้นจะทำให้ value type เป็น nullable ด้วย `?`)

การเข้าใจว่าชนิดใดเป็น value หรือ reference และ semantics ของการคัดลอก การเปรียบเทียบ และการเปลี่ยนแปลงที่ตามมา เป็นพื้นฐานสำหรับการเขียน C# ให้ถูกต้องและหลีกเลี่ยงข้อผิดพลาดเชิงแนวคิดที่พบบ่อยที่สุดของภาษา มันเป็นรากฐานของการไหลของข้อมูลในโปรแกรม และเป็นหัวข้อสัมภาษณ์ที่พบบ่อยเพราะมันเผยให้เห็นว่านักพัฒนาเข้าใจระบบชนิดข้อมูลของ C# อย่างแท้จริงหรือไม่