கூ .NET இல் மெமரி ম்যানேஜ்மென்ட் மற்றும் கார்பேஜ் கலெக்ஷன் எப்படி வேலை செய்கிறது?

Question

Accepted Answer

.NET **தானாகவே** மெமரியை **garbage collector (GC)** மூலம் நிர்வகிக்கிறது — இது managed heap-ல் objects-ஐ allocate செய்கிறது மற்றும் அணுகக்கூடிய அல்லாத objects-ஐ recover செய்கிறது, எனவே நீங்கள் manually memory-ஐ free செய்ய வேண்டியதில்லை. GC-ஐ புரிந்துகொள்ளுதல் (generational, stack/heap split, மற்றும் `IDisposable`) performance மற்றும் correctness-க்கு முக்கியமாக உள்ளது.

## 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 reachable objects-ஐ (roots: stack, static fields இலிருந்து) mark செய்கிறது மற்றும் மற்றவற்றை reclaim செய்கிறது. இது **generational** — பெரும்பாலான objects இளவயதில் சாகிறது, எனவே Gen 0 அடிக்கடி மற்றும் cheaply collect செய்யப்படுகிறது, அதே சமயம் Gen 2-ல் உள்ள long-lived objects rarely collect செய்யப்படுகிறது.

## IDisposable மற்றும் using — 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 managed memory-ஐ free செய்கிறது, ஆனால் **unmanaged resources** (file handles, DB connections, sockets) explicit cleanup-க்கு **`IDisposable`/`Dispose()`** மூலம் தேவைப்படுகிறது — `using` statement இதை deterministically guarantee செய்கிறது (நீங்கள் GC-க்கு காத்திருக்க வேண்டியதில்லை).

## Memory leaks still happen

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

## ஏன் இது முக்கியமாக இருக்கிறது

.NET memory management மற்றும் garbage collection-ஐ புரிந்துகொள்ளுதல் performant, correct C# எழுதுவதற்கான மதிப்புமிக்க senior-level கowledge — GC manual memory management-ல் இருந்து உங்களை விடுவிக்கிறது (major productivity மற்றும் safety benefit, manual `free` மற்றும் dangling pointers-ஐ நீக்குகிறது), ஆனால் *எப்படி* வேலை செய்கிறது என்பதை புரிந்துகொள்ளுதல் performance-sensitive applications மற்றும் subtle bugs-ஐ தவிர்ப்பதற்கு முக்கியமாக உள்ளது.

**generational GC** (Gen 0 frequently மற்றும் cheaply collect செய்யப்படுகிறது, Gen 2 rarely ஆனால் expensively, பெரும்பாலான objects இளவயதில் சாகிறது என்ற observation-ன் அடிப்படையில்) அறிந்திருப்பது allocation patterns மற்றும் GC pressure-ஐ பற்றி சிந்திக்க உதவுகிறது (allocations-ஐ குறைப்பது, specially short-lived objects, GC overhead-ஐ குறைக்கிறது).

**stack vs heap** distinction (value types stack-ல், reference objects heap-ல்) value/reference type model-க்கு connected.

Critically, **`IDisposable`/`Dispose()` மற்றும் `using` statement**-ஐ புரிந்துகொள்ளுதல் essential மற்றும் practical: GC *memory*-ஐ manage செய்கிறது ஆனால் *unmanaged resources*-ஐ அல்ல (file handles, database connections, sockets), அவை `using`-ல் மூலம் deterministic cleanup தேவைப்படுகிறது — இவற்றை dispose செய்யத் தவறுவது resource leaks-ஐ (ஒரு common real bug) ஏற்படுத்துகிறது.

Equally important, **memory leaks still occur** GC-க்கும் மறுபுறம் lingering references (growing static caches, un-unsubscribed event handlers subscribers-ஐ alive வைக்கும் — ஒரு classic C# leak) இலிருந்து என்பதை recognize செய்தல்.

GC-ஐயின் generational model, resource-disposal pattern (`IDisposable`/`using`), மற்றும் leaks-ன் causes-ஐ புரிந்துகொள்ளுதல் performant, leak-free C# எழுதுவதற்கு முக்கியமாக உள்ளது, specially long-running applications-ல் — efficient, correct .NET applications-ஐ build செய்யக்கூடிய developers-ஐ distinguish செய்யும் மதிப்புமிக்க knowledge ஆக இருந்து, common senior-level interview topic.