Apa perbedaan antara value types dan reference types?

Question

Accepted Answer

Tipe-tipe C# terbagi menjadi dua kategori fundamental: **value types** (menyimpan data secara langsung) dan **reference types** (menyimpan referensi/pointer ke data di heap). Keduanya berbeda dalam cara penyimpanan, penyalinan, dan perbandingan — sebuah perbedaan penting yang mempengaruhi perilaku di seluruh bahasa.

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

## Perbedaan kunci: 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!
```

Menetapkan value type menyalin data (independen); menetapkan reference type menyalin referensi (kedua nama menunjuk ke objek yang sama, jadi mutasi melalui satu mempengaruhi yang lain).

## Perbandingan dan passing ke methods

```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 ini penting

Perbedaan value-vs-reference adalah salah satu konsep paling fundamental dalam C#, dan menjelaskan berbagai perilaku dan bug — menjadikannya pengetahuan yang sangat penting.

Memahami bahwa **value types** (structs, primitif seperti int/double, enums) disalin berdasarkan nilai (salinan independen) sementara **reference types** (classes, arrays, strings) disalin berdasarkan referensi (kedua nama menunjuk ke objek yang sama) sangat penting untuk memprediksi perilaku data: memodifikasi salinan value type tidak mempengaruhi original, tetapi mutasi pada objek reference type yang dibagikan mempengaruhi semua referensi ke objek tersebut (sumber bug yang sering mengejutkan).

Perbedaan ini juga mempengaruhi **equality** (`==` membandingkan nilai untuk value types tetapi identitas referensi untuk reference types secara default), **method arguments** (value types dilewatkan sebagai salinan, referensi reference types dilewatkan berdasarkan nilai — jadi methods dapat mutasi objek yang dilewatkan tetapi bukan int yang dilewatkan), dan **nullability** (hanya reference types yang dapat null, kecuali value type dibuat nullable dengan `?`).

Memahami tipe mana yang value versus reference dan copy, comparison, dan mutation semantics yang dihasilkan adalah fundamental untuk menulis C# yang benar dan menghindari jebakan konseptual paling umum dalam bahasa — ini mendasari bagaimana data mengalir melalui program dan merupakan topik wawancara yang sering karena mengungkapkan apakah developer benar-benar memahami tipe sistem C#.