Memory management र garbage collection .NET मा कसरी काम गर्छ?

Question

Accepted Answer

.NET ले **स्वचालित रूपमा** **garbage collector (GC)** मार्फत memory को व्यवस्थापन गर्छ — यसले objects लाई managed heap मा आबंटित गर्छ र जो अब पहुँचयोग्य छैनन् तिनलाई पुनः प्राप्त गर्छ, त्यसैले तपाईंले म्यानुअली memory मुक्त गर्नु पर्दैन। 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.
```

## 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 ले पहुँचयोग्य objects लाई चिन्ह लगाउँछ (roots बाट: stack, static fields) र बाकी लाई पुनः प्राप्त गर्छ। यो **generational** छ — अधिकांश objects युवामा मर्छन्, त्यसैले Gen 0 बारम्बार र सस्तैमा जमा हुन्छ, जबकि Gen 2 मा लामो-जीवित objects विरलै जमा हुन्छन्।

## 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 मुक्त गर्छ, तर **unmanaged resources** (file handles, DB connections, sockets) लाई **`IDisposable`/`Dispose()`** मार्फत स्पष्ट सफाइ चाहिन्छ — `using` statement यो निर्धारणात्मक रूपमा गारान्टी गर्छ (तपाईंले GC को लागि प्रतीक्षा गर्नु पर्दैन)।

## Memory leaks अझै हुन्छन्

```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, सही C# लेखनको लागि मूल्यवान senior-level ज्ञान हो — जबकि GC ले तपाईंलाई manual memory management बाट मुक्त गर्छ (एक प्रमुख उत्पादकता र सुरक्षा लाभ, manual `free` र dangling pointers लाई हटाउँदै), यो कसरी काम गर्छ भनेर बुझ्नु performance-sensitive applications र सूक्ष्म bugs बिर्सन को लागि महत्त्वपूर्ण छ।

**generational GC** को ज्ञान (Gen 0 बारम्बार र सस्तैमा जमा हुन्छ, Gen 2 विरलै तर खर्चीलै, अधिकांश objects युवामा मर्छन् भन्ने अवलोकनमा आधारित) allocation patterns र GC pressure को बारेमा तर्क गर्न मद्दत गर्छ (allocations को घटाउँनु, विशेष गरी short-lived objects को, GC overhead कम गर्छ)।

**stack vs heap** को भेद (value types stack मा, reference objects heap मा) value/reference type model सँग जोडिन्छ।

आलोचनात्मकरूपमा, **`IDisposable`/`Dispose()` र `using` statement** को ज्ञान अत्यावश्यक र व्यावहारिक छ: GC ले *memory* को व्यवस्थापन गर्छ तर *unmanaged resources* (file handles, database connections, sockets) को होइन, जसलाई `using` मार्फत निर्धारणात्मक सफाइ चाहिन्छ — यी dispose गर्न असफल हुनु resource leaks को कारण बन्छ (एक सामान्य साँचो bug)।

समान रूपमा महत्त्वपूर्ण छ कि **GC को बावजुद memory leaks अझै पनि हुन्छन्** भनेर पहिचान गर्नु, lingering references बाट (बढ्दो static caches, un-unsubscribed event handlers जो subscribers लाई जीवित रखन्छन् — एक क्लासिक C# leak)।

GC को generational model, resource-disposal pattern (`IDisposable`/`using`), र leaks को कारणहरू बुझ्नु performant, leak-free C# लेखनको लागि महत्त्वपूर्ण छ, विशेषगरी long-running applications मा — यसलाई मूल्यवान ज्ञान बनाउँदै जो efficient, सही .NET applications निर्माण गर्न सक्ने developers लाई छुट्ट्याउँछ र एक सामान्य senior-level interview विषय हो।