Bagaimana pengurusan memori dan garbage collection berfungsi dalam .NET?

Question

Accepted Answer

.NET menguruskan memori **secara automatik** melalui **garbage collector (GC)** — ia memperuntukkan objek pada managed heap dan menuntut semula yang tidak lagi boleh dicapai, jadi anda tidak perlu membebaskan memori secara manual. Memahami GC (generational, pembahagian stack/heap, dan `IDisposable`) penting untuk prestasi dan ketepatan.

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

## Garbage collector generational

```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 menandakan objek yang boleh dicapai (daripada roots: stack, static fields) dan menuntut semula yang selebihnya. Ia **generational** — kebanyakan objek mati muda, jadi Gen 0 dikutip kerap dan murah, manakala objek berumur panjang dalam Gen 2 dikutip jarang.

## IDisposable dan using — untuk sumber tidak terurus

```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 memori terurus, tetapi **sumber tidak terurus** (file handles, sambungan DB, sockets) memerlukan pembersihan eksplisit melalui **`IDisposable`/`Dispose()`** — pernyataan `using` menjamin ini secara deterministik (anda tidak perlu menunggu GC).

## Kebocoran memori masih berlaku

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

Memahami pengurusan memori .NET dan garbage collection ialah pengetahuan peringkat senior yang bernilai untuk menulis C# yang berprestasi dan betul — walaupun GC membebaskan anda daripada pengurusan memori manual (manfaat produktiviti dan keselamatan utama, menghapuskan `free` manual dan dangling pointers), memahami *bagaimana* ia berfungsi penting untuk aplikasi yang sensitif prestasi dan mengelakkan pepijat yang halus.

Mengetahui **generational GC** (Gen 0 dikutip kerap dan murah, Gen 2 jarang tetapi mahal, berdasarkan pemerhatian bahawa kebanyakan objek mati muda) membantu anda menaakul tentang corak peruntukan dan tekanan GC (mengurangkan peruntukan, terutamanya objek berumur pendek, mengurangkan overhead GC).

Perbezaan **stack vs heap** (value types pada stack, objek rujukan pada heap) berkaitan dengan model jenis nilai/rujukan.

Yang penting, memahami **`IDisposable`/`Dispose()` dan pernyataan `using`** adalah penting dan praktikal: GC menguruskan *memori* tetapi bukan *sumber tidak terurus* (file handles, sambungan pangkalan data, sockets), yang memerlukan pembersihan deterministik melalui `using` — kegagalan untuk membuang ini menyebabkan kebocoran sumber (pepijat sebenar yang biasa).

Sama pentingnya ialah mengenali bahawa **kebocoran memori masih berlaku** walaupun ada GC, daripada rujukan yang berlarutan (caches static yang berkembang, event handlers yang tidak dibatalkan langganan yang mengekalkan subscribers hidup — kebocoran C# yang klasik).

Memahami model generational GC, corak pelupusan sumber (`IDisposable`/`using`), dan punca kebocoran adalah penting untuk menulis C# yang berprestasi dan bebas kebocoran, terutamanya dalam aplikasi yang berjalan lama — menjadikannya pengetahuan bernilai yang membezakan pembangun yang boleh membina aplikasi .NET yang cekap dan betul serta merupakan topik temu duga peringkat senior yang biasa.