Apakah itu records dalam C#?

Question

Accepted Answer

**Records** (C# 9+) ialah cara yang ringkas untuk mentakrifkan jenis yang terutamanya merupakan **pembawa data tak boleh ubah (immutable)** dengan **kesamaan berasaskan nilai (value-based equality)**. Ia menjana boilerplate secara automatik (constructor, kesamaan, `ToString`, dsb.), menjadikannya sesuai untuk DTO, nilai domain, dan pemodelan data.

## Mentakrifkan record (sintaks positional)

```csharp
// one line generates: constructor, properties, equality, ToString, deconstruction
public record Person(string Name, int Age);

var p1 = new Person("Ann", 30);
p1.Name;                          // "Ann" (read-only property)
Console.WriteLine(p1);             // Person { Name = Ann, Age = 30 } — ToString generated
```

Sintaks positional `record Person(string Name, int Age)` menjana segalanya — properties, constructor, `ToString`, kesamaan, deconstruction — menghapuskan boilerplate yang diperlukan oleh class biasa.

## Kesamaan berasaskan nilai (perbezaan utama daripada classes)

```csharp
var a = new Person("Ann", 30);
var b = new Person("Ann", 30);
a == b;        // TRUE — records compare by VALUE (all properties equal)
// (a regular class would be FALSE here — classes compare by reference)
```

Tidak seperti classes (yang membandingkan mengikut identiti rujukan), records membandingkan mengikut **nilai** — dua record dengan nilai property yang sama adalah sama. Inilah tepat apa yang anda mahukan untuk objek data.

## Ketakbolehubahan dan mutasi tanpa-musnah (with)

```csharp
public record Person(string Name, int Age);   // properties are init-only (immutable)

var p1 = new Person("Ann", 30);
var p2 = p1 with { Age = 31 };   // `with` creates a COPY with some properties changed
// p1 unchanged (immutable); p2 = Person { Name = Ann, Age = 31 }
```

Records adalah tak boleh ubah secara lalai, dan **ekspresi `with`** mencipta salinan yang diubah suai (mutasi tanpa-musnah) — sesuai untuk bekerja dengan data tak boleh ubah.

## record class vs record struct

```csharp
public record class Ref(int X);    // a reference type (default) with value equality
public record struct Val(int X);   // a VALUE type record (C# 10)
```

## Mengapa ia penting

Records ialah ciri C# moden yang penting (C# 9+) yang menjadikan pentakrifan jenis data tak boleh ubah ringkas dan betul, jadi memahaminya bernilai untuk pembangunan C# moden.

Manfaat utamanya menangani keperluan sebenar: ia **menghapuskan boilerplate** (menjana constructors, properties, `ToString`, kesamaan, dan deconstruction secara automatik daripada pengisytiharan satu baris — berbanding kod yang banyak yang diperlukan oleh class biasa), dan ia menyediakan **kesamaan berasaskan nilai** (dua record dengan property yang sama adalah sama, tidak seperti classes yang membandingkan mengikut rujukan) — yang merupakan tepat tingkah laku yang anda mahukan untuk objek data, DTO, dan nilai domain, dan yang classes salah secara lalai.

Records juga **tak boleh ubah secara lalai** dengan **ekspresi `with`** yang elegan untuk mutasi tanpa-musnah (mencipta salinan yang diubah suai), menyokong gaya tak boleh ubah dan berfungsi yang semakin digemari untuk kod yang lebih selamat dan boleh diramal.

Memahami records — sintaks ringkas, kesamaan nilai, ketakbolehubahan dengan `with`, dan record structs — bernilai untuk menulis C# moden yang bersih, kerana ia merupakan cara idiomatik untuk memodelkan data (DTO, model API, value objects, keadaan tak boleh ubah) dan digunakan secara meluas dalam codebase semasa.

Mengetahui bila menggunakan record (data tak boleh ubah dengan semantik nilai) berbanding class (objek boleh ubah dengan identiti dan tingkah laku kaya) mencerminkan kefasihan dengan C# moden.

Memandangkan records memudahkan pemodelan data secara dramatik sambil menyediakan kesamaan dan ketakbolehubahan yang betul — keperluan biasa yang dahulunya membosankan dan terdedah kepada ralat — ia merupakan ciri penting yang kerap digunakan dan menjadi ciri tersendiri kod C# moden yang bersih.