Apa itu records di C#?

Question

Accepted Answer

**Records** (C# 9+) adalah cara ringkas untuk mendefinisikan tipe yang terutama **pembawa data immutable** dengan **kesamaan berbasis nilai**. Mereka secara otomatis menghasilkan boilerplate (constructor, equality, `ToString`, dll.), menjadikannya ideal untuk DTOs, domain values, dan data modeling.

## Mendefinisikan record (positional syntax)

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

Positional syntax `record Person(string Name, int Age)` menghasilkan semuanya — properties, constructor, `ToString`, equality, deconstruction — menghilangkan boilerplate yang akan dibutuhkan class biasa.

## Kesamaan berbasis nilai (perbedaan kunci dari class)

```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 class (yang membandingkan berdasarkan reference identity), records membandingkan berdasarkan **nilai** — dua record dengan nilai property yang sama adalah equal. Ini persis apa yang Anda inginkan untuk data objects.

## Immutability dan non-destructive mutation (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 secara default immutable, dan **`with` expression** membuat modified copy (non-destructive mutation) — ideal untuk bekerja dengan immutable data.

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

Records adalah fitur C# modern yang penting (C# 9+) yang membuat pendefinisian tipe data immutable ringkas dan benar, jadi memahaminya berharga untuk pengembangan C# modern.

Manfaat kunci mereka mengatasi kebutuhan nyata: mereka **menghilangkan boilerplate** (secara otomatis menghasilkan constructors, properties, `ToString`, equality, dan deconstruction dari deklarasi satu baris — versus kode substansial yang dibutuhkan class biasa), dan mereka menyediakan **kesamaan berbasis nilai** (dua records dengan properties yang equal adalah equal, tidak seperti class yang membandingkan berdasarkan reference) — yang persis perilaku yang Anda inginkan untuk data objects, DTOs, dan domain values, dan yang class dapatkan secara salah secara default.

Records juga **immutable secara default** dengan **`with` expression** yang elegan untuk non-destructive mutation (membuat modified copies), mendukung gaya immutable, functional yang semakin disukai untuk kode yang lebih aman dan dapat diprediksi.

Memahami records — syntax ringkas, value equality, immutability dengan `with`, dan record structs — berharga untuk menulis C# modern yang bersih, karena mereka adalah cara idiomatik untuk memodelkan data (DTOs, API models, value objects, immutable state) dan secara luas digunakan dalam codebase saat ini.

Mengetahui kapan menggunakan record (immutable data dengan value semantics) versus class (mutable objects dengan identity dan rich behavior) mencerminkan fluency dengan C# modern.

Karena records secara dramatis menyederhanakan data modeling sambil menyediakan equality dan immutability yang benar — kebutuhan umum yang membosankan dan rentan terhadap error sebelumnya — mereka adalah fitur penting, frequently-used yang menjadi ciri khas C# modern yang bersih.