.NET में memory management और garbage collection कैसे काम करते हैं?

Question

Accepted Answer

.NET memory को **garbage collector (GC)** के माध्यम से **स्वचालित रूप से** प्रबंधित करता है — यह objects को managed heap पर allocate करता है और उन्हें पुनः प्राप्त करता है जो अब reachable नहीं हैं, इसलिए आपको manually memory free नहीं करनी पड़ती। GC को समझना (generational, stack/heap विभाजन, और `IDisposable`) performance और correctness के लिए मायने रखता है।

## stack बनाम 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 reachable objects को चिह्नित करता है (roots से: stack, static fields) और बाकी को पुनः प्राप्त करता है। यह **generational** है — अधिकांश objects जल्दी मर जाते हैं, इसलिए Gen 0 अक्सर और सस्ते में collect किया जाता है, जबकि Gen 2 में long-lived objects शायद ही कभी 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) को **`IDisposable`/`Dispose()`** के माध्यम से स्पष्ट cleanup की आवश्यकता होती है — `using` statement इसकी deterministically गारंटी देता है (आप 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 से मुक्त करता है (एक प्रमुख productivity और safety लाभ, manual `free` और dangling pointers को समाप्त करते हुए), यह समझना कि यह *कैसे* काम करता है performance-sensitive applications के लिए और सूक्ष्म bugs से बचने के लिए मायने रखता है।

**generational GC** को जानना (Gen 0 अक्सर और सस्ते में collect किया जाता है, Gen 2 शायद ही कभी लेकिन महंगे में, इस अवलोकन के आधार पर कि अधिकांश objects जल्दी मर जाते हैं) आपको allocation patterns और GC pressure के बारे में तर्क करने में मदद करता है (allocations को कम करना, विशेष रूप से short-lived objects का, GC overhead को कम करता है)।

**stack बनाम heap** का अंतर (value types stack पर, reference objects heap पर) value/reference type मॉडल से जुड़ता है।

महत्वपूर्ण रूप से, **`IDisposable`/`Dispose()` और `using` statement** को समझना आवश्यक और व्यावहारिक है: GC *memory* का प्रबंधन करता है लेकिन *unmanaged resources* का नहीं (file handles, database connections, sockets), जिन्हें `using` के माध्यम से deterministic cleanup की आवश्यकता होती है — इन्हें dispose करने में विफलता resource leaks का कारण बनती है (एक सामान्य वास्तविक bug)।

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

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