Kako deluje upravljanje pomnilnika in zbiranje smeti v .NET?

Question

Accepted Answer

.NET upravlja pomnilnik **avtomatsko** prek **zbiralnika smeti (GC)** — dodeli objekte upravljanemu kopičenju in jih otkrije, ko niso več dosegljivi, zato ročno ne osvobajate pomnilnika. Razumevanje GC (generacijskega, delitve medpomnilnikom/kopičenjem in `IDisposable`) je pomembno za uspešnost in pravilnost.

## Medpomnilnik proti kopičenju

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

```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či dosegljive objekte (iz korenin: medpomnilnik, statična polja) in otkrije ostale. Je **generacijski** — večina objektov umre mlada, zato se Gen 0 zbira pogosto in poceni, medtem ko se dolgoživljivi objekti v Gen 2 zbbirajodela redko.

## IDisposable in using — za neupravljane vire

```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 osvobodi upravljani pomnilnik, vendar **neupravljani viri** (deskriptorji datotek, povezave v bazo podatkov, vtičnice) potrebujejo izrecno čiščenje prek **`IDisposable`/`Dispose()`** — stavek `using` to zagotavlja determinističko (ne čakate na GC).

## Puščanje pomnilnika se vseeno zgodi

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

## Zakaj je to pomembno

Razumevanje upravljanja pomnilnika in zbiranja smeti v .NET je dragoceno znanje na ravni starejšega razvijalca za pisanje zmogljivega in pravilnega C# — medtem ko vas GC osvobodi ročnega upravljanja pomnilnika (velika prednost za produktivnost in varnost, kar izključuje ročno `free` in viseče kazalce), razumevanje *kako* deluje je pomembno za aplikacije občutljive na uspešnost in izogibanju subtilnim napakam.

Znanje **generacijskega GC** (Gen 0 zbran pogosto in poceni, Gen 2 redko vendar drago, na podlagi opazovanja, da večina objektov umre mlada) vam pomaga sklepati o vzorcih dodelitve in GC pritisku (zmanjšanje dodelitve, zlasti kratkoživljenih objektov, zmanjša GC režijo).

Razlikovanje **medpomnilnika in kopičenja** (vrednostni tipi na medpomnilniku, referenčni objekti na kopičenju) je povezano z modelom vrednostnih/referenčnih tipov.

Kritično je razumevanje **`IDisposable`/`Dispose()` in stavka `using`** je bistveno in praktično: GC upravlja *pomnilnikom* vendar ne *neupravljanimi viri* (deskriptorji datotek, povezave v bazo podatkov, vtičnice), ki potrebujejo determinističko čiščenje prek `using` — neuspešno čiščenje teh povzroči puščanje virov (pogosta resna napaka).

Enako pomembno je prepoznavanje, da se **puščanje pomnilnika vseeno zgodi** kljub GC, zaradi vztrajnih referenc (naraščajoči statični predpomnilniki, naročeni ročniki dogodkov, ki vzdrževajo naročnike živimi — klasična C# napaka).

Razumevanje GC generacijskega modela, vzorca za zavržbo virov (`IDisposable`/`using`) in vzrokov za puščanje je pomembno za pisanje zmogljive in brez puščanja C#, zlasti v dolgotrajnih aplikacijah — kar ga naredi dragoceno znanje, ki razlikuje razvijalce, ki lahko gradijo učinkovite, pravilne .NET aplikacije in je pogosta tema intervjuja na višji ravni.