Kako funkcionira upravljanje memorijom i garbage collection u .NET-u?

Question

Accepted Answer

.NET upravlja memorijom **automatski** putem **garbage collector-a (GC)** — alocira objekte na upravljanoj heap memoriji i oslobađa one koje više nisu dostižne, tako da ne trebate ručno oslobađati memoriju. Razumijevanje GC-a (generacijski, podjela stack/heap, i `IDisposable`) važno je za performanse i ispravnost.

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

## Generacijski 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 označava dostižne objekte (iz korijena: stack, statička polja) i oslobađa ostatak. Radi **generacijski** — većina objekata umre mlada, pa se Gen 0 prikuplja često i jeftino, dok se dugovječni objekti u Gen 2 prikupljaju rijetko.

## IDisposable i using — za nesterovane resurse

```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 oslobađa upravljanu memoriju, ali **nesterovani resursi** (file handle-i, DB konekcije, socket-i) trebaju eksplicitno čišćenje putem **`IDisposable`/`Dispose()`** — `using` iskaz to jamči determinističkim putem (ne trebate čekati na GC).

## Memory leakovi se i dalje događaju

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

## Zašto je važno

Razumijevanje upravljanja memorijom .NET-a i garbage collection-a vrijedna je znanja za razinu seniora za pisanje performantnog i ispravnog C# koda — dok vas GC oslobađa od ručnog upravljanja memorijom (značajna prednost u produktivnosti i sigurnosti, eliminirajući ručne `free` i viseće pokazivače), razumijevanje *kako* to funkcionira važno je za aplikacije osjetljive na performanse i izbjegavanje suptilnih grešaka.

Znanje o **generacijskom GC-u** (Gen 0 se prikuplja često i jeftino, Gen 2 rijetko ali skupo, temeljeno na opservaciji da većina objekata umre mlada) pomaže vam zaključiti o uzorcima alokacije i GC pritisku (smanjivanje alokacija, posebno kratkovječnih objekata, smanjuje GC overhead).

Razlika **stack vs heap** (tipovi vrijednosti na stacku, objekti reference na heapu) povezuje se s value/reference type modelom.

Kritično je razumijevanje **`IDisposable`/`Dispose()` i `using` iskaza** — esencijalno i praktično: GC upravlja *memorijom* ali ne *nesterovanim resursima* (file handle-i, database konekcije, socket-i), koji trebaju determinističko čišćenje putem `using` — neuspješno oslobađanje tih resursa uzrokuje curenja resursa (česta prava greška).

Jednako važno je prepoznavanje da se **memory leakovi i dalje javljaju** unatoč GC-u, iz trajnih referenci (rastući statički cachei, neodjavljeni event handleri koji čuvaju subscriber-e žive — klasičan C# leak).

Razumijevanje generacijskog modela GC-a, uzorca za oslobađanje resursa (`IDisposable`/`using`), i uzroka curenja važno je za pisanje performantnog i bez curenja C# koda, posebno u dugoročno pokrenutim aplikacijama — čineći to vrijednim znanjem koje razlikuje razvojne inženjere koji mogu graditi učinkovite i ispravne .NET aplikacije i predstavlja čest tema senior-level intervjua.