Bagaimana manajemen memori dan garbage collection bekerja di .NET?

Question

Accepted Answer

.NET mengelola memori **secara otomatis** melalui **garbage collector (GC)** — ia mengalokasikan objek di managed heap dan membebaskan yang tidak lagi dapat dijangkau, sehingga Anda tidak perlu secara manual membebaskan memori. Memahami GC (generational, pembagian stack/heap, dan `IDisposable`) penting untuk performa dan kebenaran.

## Stack vs heap

```text
Stack → value types (locals), method frames; fast, automatically freed when scope ends.
Heap  → reference type objects (class instances); managed by the GC.
A reference variable lives on the stack but points to its object on the heap.
```

## The generational garbage collector

```text
The GC divides the heap into GENERATIONS (based on the "most objects die young" idea):
  Gen 0 → newest objects; collected FREQUENTLY (fast, cheap)
  Gen 1 → survived one collection
  Gen 2 → long-lived objects; collected RARELY (expensive)
  (+ Large Object Heap for big objects)
→ Collecting young generations often + old ones rarely makes the GC efficient.
```

GC menandai objek yang dapat dijangkau (dari root: stack, static fields) dan membebaskan sisanya. GC bersifat **generational** — sebagian besar objek mati muda, jadi Gen 0 dikumpulkan sering dan murah, sedangkan objek long-lived di Gen 2 dikumpulkan jarang.

## IDisposable dan using — untuk unmanaged resources

```csharp
// the GC handles MANAGED memory, but NOT unmanaged resources (files, connections, handles)
// → implement IDisposable and use `using` for deterministic cleanup
using (var file = new StreamReader("data.txt"))
{
    // use file
}   // file.Dispose() called automatically — releases the file handle NOW
```

GC membebaskan managed memory, tetapi **unmanaged resources** (file handles, DB connections, sockets) membutuhkan pembersihan eksplisit melalui **`IDisposable`/`Dispose()`** — pernyataan `using` menjamin ini secara deterministik (Anda tidak menunggu GC).

## Memory leaks masih bisa terjadi

```text
The GC frees only UNREACHABLE objects. "Leaks" come from lingering references:
  ✗ static collections/caches that only grow
  ✗ un-unsubscribed event handlers (the publisher keeps subscribers alive!)
  ✗ long-lived objects holding references to short-lived ones
```

## Mengapa ini penting

Memahami manajemen memori .NET dan garbage collection adalah pengetahuan tingkat senior yang berharga untuk menulis C# yang performan dan benar — sementara GC membebaskan Anda dari manajemen memori manual (keuntungan produktivitas dan keamanan besar, menghilangkan `free` manual dan dangling pointers), memahami *bagaimana* cara kerjanya penting untuk aplikasi yang peka terhadap performa dan menghindari bug yang halus.

Mengetahui **generational GC** (Gen 0 dikumpulkan sering dan murah, Gen 2 jarang tetapi mahal, berdasarkan pengamatan bahwa sebagian besar objek mati muda) membantu Anda bernalar tentang pola alokasi dan GC pressure (mengurangi alokasi, terutama objek short-lived, menurunkan overhead GC).

Pembedaan **stack vs heap** (value types di stack, reference objects di heap) terhubung ke model value/reference type.

Kritisnya, memahami **`IDisposable`/`Dispose()` dan pernyataan `using`** sangat penting dan praktis: GC mengelola *memory* tetapi bukan *unmanaged resources* (file handles, database connections, sockets), yang membutuhkan pembersihan deterministik melalui `using` — gagal untuk dispose resource ini menyebabkan resource leaks (bug nyata yang umum).

Sama pentingnya adalah mengakui bahwa **memory leaks masih bisa terjadi** meskipun ada GC, dari referensi yang tertinggal (growing static caches, un-unsubscribed event handlers yang membuat subscribers tetap hidup — bocor C# klasik).

Memahami model generational GC, pola resource-disposal (`IDisposable`/`using`), dan penyebab leaks penting untuk menulis C# yang performan dan bebas leak, terutama dalam aplikasi long-running — menjadikannya pengetahuan berharga yang membedakan developer yang dapat membangun aplikasi .NET yang efisien dan benar dan merupakan topik wawancara tingkat senior yang umum.