Sự khác biệt giữa value type và reference type là gì?

Question

Accepted Answer

Các kiểu trong C# thuộc hai nhóm cơ bản: **value type** (lưu trực tiếp dữ liệu) và **reference type** (lưu một tham chiếu/con trỏ đến dữ liệu trên heap). Chúng khác nhau ở cách được lưu trữ, sao chép và so sánh — một sự phân biệt then chốt ảnh hưởng đến hành vi xuyên suốt ngôn ngữ.

## Hai nhóm

```text
Value type      → struct, int, double, bool, char, enum, DateTime, decimal
                  Lưu TRỰC TIẾP (trên stack với biến cục bộ); sao chép THEO GIÁ TRỊ.
Reference type  → class, string, array, object, interface, delegate
                  Biến giữ một THAM CHIẾU đến dữ liệu trên heap; sao chép THEO THAM CHIẾU.
```

## Khác biệt then chốt: ngữ nghĩa sao chép

```csharp
// VALUE type — phép gán SAO CHÉP giá trị (độc lập)
int a = 5;
int b = a;      // b là một BẢN SAO
b = 10;         // a vẫn là 5

struct Point { public int X; }
Point p1 = new() { X = 1 };
Point p2 = p1;  // SAO CHÉP toàn bộ struct
p2.X = 99;      // p1.X vẫn là 1

// REFERENCE type — phép gán sao chép THAM CHIẾU (cả hai trỏ đến CÙNG một object)
class Box { public int Value; }
Box box1 = new() { Value = 1 };
Box box2 = box1;   // cả hai tham chiếu đến CÙNG một Box
box2.Value = 99;   // box1.Value giờ cũng là 99!
```

Gán một value type sẽ sao chép dữ liệu (độc lập); gán một reference type sẽ sao chép tham chiếu (cả hai tên cùng trỏ đến một object, nên thay đổi qua một bên sẽ ảnh hưởng bên kia).

## So sánh và truyền vào method

```csharp
// == so sánh GIÁ TRỊ với value type, THAM CHIẾU (định danh) với reference type
string s1 = "hi"; // (string đặc biệt — == so sánh nội dung)
Box b1 = new(), b2 = new();
b1 == b2;   // false — khác object (so sánh tham chiếu mặc định)

// method nhận một BẢN SAO của value type, nhận tham chiếu (theo giá trị) với reference type
void Modify(Box b) { b.Value = 100; }   // ảnh hưởng object của caller
void Modify(int x) { x = 100; }           // KHÔNG ảnh hưởng int của caller
```

## null

```text
Reference type có thể null (không có object). Value type KHÔNG THỂ null
(trừ khi được làm nullable: int? — một Nullable<int>).
```

## Tại sao điều này quan trọng

Sự phân biệt value-vs-reference là một trong những khái niệm nền tảng nhất trong C#, và nó giải thích nhiều hành vi cũng như lỗi — khiến nó trở thành kiến thức thiết yếu.

Hiểu rằng **value type** (struct, kiểu nguyên thủy như int/double, enum) được sao chép theo giá trị (bản sao độc lập) trong khi **reference type** (class, array, string) được sao chép theo tham chiếu (cả hai tên cùng trỏ đến một object) là điều cốt yếu để dự đoán dữ liệu sẽ hành xử thế nào: sửa một bản sao value type không ảnh hưởng bản gốc, nhưng thay đổi một object reference type được chia sẻ sẽ ảnh hưởng đến mọi tham chiếu đến nó (một nguồn lỗi gây bất ngờ phổ biến).

Sự phân biệt này cũng ảnh hưởng đến **so sánh bằng** (`==` so sánh giá trị với value type nhưng so sánh định danh tham chiếu với reference type theo mặc định), **đối số của method** (value type được truyền dưới dạng bản sao, tham chiếu của reference type được truyền theo giá trị — nên method có thể thay đổi một object được truyền vào nhưng không thay đổi được một int được truyền vào), và **tính nullable** (chỉ reference type mới có thể null, trừ khi value type được làm nullable với `?`).

Hiểu kiểu nào là value vs reference cùng ngữ nghĩa sao chép, so sánh và thay đổi đi kèm là nền tảng để viết C# đúng và tránh những cạm bẫy khái niệm phổ biến nhất của ngôn ngữ — nó nâng đỡ cách dữ liệu luân chuyển qua một chương trình và là chủ đề phỏng vấn thường gặp chính vì nó cho thấy lập trình viên có thực sự hiểu hệ thống kiểu của C# hay không.