ਕੀ .NET ਵਿੱਚ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਅਤੇ ਗਾਰਬੇਜ ਕਲੈਕਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

Question

Accepted Answer

.NET **ਆਪਣੇ ਆਪ** **garbage collector (GC)** ਦੇ ਜ਼ਰੀਏ ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ — ਇਹ managed heap ਉੱਤੇ objects ਨੂੰ allocate ਕਰਦਾ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ reclaim ਕਰਦਾ ਹੈ ਜੋ ਹੁਣ reachable ਨਹੀਂ ਹਨ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਮੈਮੋਰੀ ਨੂੰ ਹੱਥੋਂ free ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ। GC ਨੂੰ ਸਮਝਣਾ (generational, stack/heap split, ਅਤੇ `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.
```

## ਜਨਰੇਸ਼ਨਲ ਗਾਰਬੇਜ ਕਲੈਕਟਰ

```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 ਨੂੰ mark ਕਰਦਾ ਹੈ (roots ਤੋਂ: stack, static fields) ਅਤੇ ਬਾਕੀ ਨੂੰ reclaim ਕਰਦਾ ਹੈ। ਇਹ **generational** ਹੈ — ਬਿਆਨ ਹਾਂ ਜ਼ਿਆਦਾਤਰ objects ਛੇਤੀ ਨਾਲ ਮਰ ਜਾਂਦੇ ਹਨ, ਇਸ ਲਈ Gen 0 ਨੂੰ ਅਕਸਰ ਅਤੇ ਸਸਤੇ ਢੰਗ ਨਾਲ collect ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਦੋਂ Gen 2 ਵਿੱਚ ਲੰਬੇ-ਬਾਕੀ ਆਏ 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()`** ਦੇ ਜ਼ਰੀਏ explicit cleanup ਦੀ ਲੋੜ ਹੈ — `using` statement ਇਸ ਨੂੰ deterministically ਗ੍ਰਹਣ ਕਰਦਾ ਹੈ (ਤੁਹਾਨੂੰ GC ਦੀ ਉਡੀਕ ਨਹੀਂ ਕਰਨੀ ਪਵੇ)।

## ਮੈਮੋਰੀ ਲੀਕ ਅਜੇ ਵੀ ਹੁੰਦਾ ਹੈ

```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 ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਅਤੇ garbage collection ਨੂੰ ਸਮਝਣਾ performant, ਸਹੀ C# ਲਿਖਣ ਲਈ valuable senior-level ਗਿਆਨ ਹੈ — ਜਦੋਂ GC ਤੁਹਾਨੂੰ manual memory management ਤੋਂ ਆਜ਼ਾਦ ਕਰਦਾ ਹੈ (ਇਕ ਮਹਾਨ productivity ਅਤੇ safety ਲਾਭ, manual `free` ਅਤੇ dangling pointers ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ), ਇਹ ਸਮਝਣਾ *ਕਿ* ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ performance-sensitive applications ਅਤੇ subtle bugs ਨੂੰ ਰੋਕਣ ਲਈ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ।

**generational GC** ਨੂੰ ਜਾਣਨਾ (Gen 0 ਅਕਸਰ ਅਤੇ ਸਸਤੇ ਢੰਗ ਨਾਲ collect ਹੁੰਦਾ ਹੈ, Gen 2 ਬਹੁਤ ਘੱਟ ਪਰ ਮਹਿੰਗੇ ਢੰਗ ਨਾਲ, ਇਸ ਨਿਰੀਖਣ ਦੀ ਬਿਨਾਂ ਕਿ ਬਿਆਨ ਹਾਂ ਬਿਲਕਲ ਆਮ ਆਂਕੜੇ ਛੇਤੀ ਨਾਲ ਮਰ ਜਾਂਦੇ ਹਨ) allocation patterns ਅਤੇ GC pressure ਬਾਰੇ ਵਿਚਾਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ (allocations ਨੂੰ ਘਟਾਉਣਾ, ਖਾਸ ਤੌਰ ਤੇ short-lived objects, GC overhead ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ)।

**stack ਬਨਾਮ 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` ਦੇ ਜ਼ਰੀਏ deterministic cleanup ਦੀ ਲੋੜ ਹੈ — ਇਨ੍ਹਾਂ ਨੂੰ dispose ਕਰਨ ਵਿੱਚ ਅਸਫਲਤਾ resource leaks ਦਾ ਕਾਰਨ ਬਣਦੀ ਹੈ (ਇਕ ਆਮ ਅਸਲ bug)।
erਬਰਾਬਰ ਮਹੱਤਵਪੂਰਨ ਇਹ ਜਾਣਕਾਰੀ ਹੈ ਕਿ **memory leaks ਅਜੇ ਵੀ ਹੁੰਦਾ ਹੈ** GC ਦੀ ਮੌਜੂਦਗੀ ਦੀ ਬਾਵਜੂਦ, lingering references ਤੋਂ (growing 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 ਵਿੱਚ — ਇਸ ਨੂੰ valuable ਗਿਆਨ ਬਣਾ ਦਿੰਦਾ ਹੈ ਜੋ developers ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ ਜੋ efficient, correct .NET applications ਬਣਾ ਸਕਦੇ ਹਨ ਅਤੇ ਇਕ ਆਮ senior-level interview ਵਿਸ਼ਾ ਹੈ।