Apakah perbezaan antara jenis nilai (value type) dan jenis rujukan (reference type)?

Question

Accepted Answer

Jenis C# terbahagi kepada dua kategori asas: **value types** (menyimpan data secara terus) dan **reference types** (menyimpan rujukan/pointer kepada data pada heap). Kedua-duanya berbeza dari segi cara ia disimpan, disalin, dan dibandingkan — satu pembezaan penting yang mempengaruhi tingkah laku di seluruh bahasa ini.

## Dua kategori

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

## Perbezaan utama: semantik penyalinan

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

Menetapkan value type akan menyalin data tersebut (bebas); menetapkan reference type akan menyalin rujukan (kedua-dua nama menunjuk kepada objek yang sama, jadi pengubahan melalui satu akan menjejaskan yang lain).

## Perbandingan dan penghantaran kepada kaedah

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

## Mengapa ia penting

Pembezaan antara value dan reference ialah salah satu konsep paling asas dalam C#, dan ia menjelaskan pelbagai tingkah laku dan pepijat — menjadikannya pengetahuan yang amat penting.

Memahami bahawa **value types** (struct, primitif seperti int/double, enum) disalin mengikut nilai (salinan bebas) manakala **reference types** (class, array, string) disalin mengikut rujukan (kedua-dua nama menunjuk kepada objek yang sama) adalah penting untuk meramal bagaimana data berkelakuan: mengubah suai salinan value type tidak menjejaskan yang asal, tetapi mengubah objek reference type yang dikongsi akan menjejaskan semua rujukan kepadanya (punca biasa pepijat yang mengejutkan).

Pembezaan ini juga mempengaruhi **kesamaan** (`==` membandingkan nilai bagi value type tetapi identiti rujukan bagi reference type secara lalai), **argumen kaedah** (value type dihantar sebagai salinan, rujukan reference type dihantar mengikut nilai — jadi kaedah boleh mengubah objek yang dihantar tetapi bukan int yang dihantar), dan **kebolehnullan** (hanya reference type boleh menjadi null, melainkan value type dijadikan nullable dengan `?`).

Memahami jenis mana yang merupakan value berbanding reference dan semantik penyalinan, perbandingan, serta pengubahan yang terhasil adalah asas untuk menulis C# yang betul dan mengelakkan lubang konsep yang paling biasa dalam bahasa ini — ia mendasari bagaimana data mengalir melalui sesebuah program dan merupakan topik temu duga yang kerap kerana ia mendedahkan sama ada seorang pembangun benar-benar memahami sistem jenis C#.