Yaya Memory Management da Garbage Collection ke aiki a .NET?

Question

Accepted Answer

.NET yana sarrafa alaƙa **ta atomatik** ta hanyar **garbage collector (GC)** — yana ƙirƙira abubuwan akan managed heap kuma yana dawo da waɗanda ba za su isa ba, don haka ba ka bugi alaƙa ta hannu. Fahimtar GC (generational, stack/heap rabuwa, da `IDisposable`) yana da mahimmanci don aiki da daidai-daidai.

## Stack da 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.
```

## Garbage collector na generational

```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 yana alamta abubuwan da ake isa (daga tushe: stack, static fields) kuma yana dawo da sauran. Yana da **generational** — yawancin abubuwan suna mutu da sauri, don haka Gen 0 yana tsammani sau da yawa da saufi, yayin da abubuwan da suka dade a Gen 2 ba su tsammani sai kaɗan.

## IDisposable da using — don ba-sarraffaffiyar alaki

```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 yana sarrafa alaken da aka sarrafa, amma **ba-sarraffaffiyar alaki** (filen handles, DB connections, sockets) suna buƙatar wadata tsattsauran sakamako ta hanyar **`IDisposable`/`Dispose()`** — bayanin `using` yana ba da daidai-daidai (ba ka jira GC ba).

## Kuɗi na alaken yanzu yana iya faruwa

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

## Yaya yana da mahimmanci

Fahimtar sarraffaffiyar alaken .NET da garbage collection ita ce ilimin mahimmanci na babbar jiya don rubutu C# mai aiki, mahimmanci — yayin da GC yana kau maka daga sarraffaffiyar alaken ta hannu (babbar fa'ida da aminci, kawar da hannu `free` da masu nisa), fahimtar *yaya* yana aiki yana da mahimmanci don aikace-aikacen da ke buƙatar saurin aiki da kaiwa daga rashin daidai.

Sanin **generational GC** (Gen 0 yana tsammani sau da yawa da saufi, Gen 2 kaɗan amma kɗar, bisa lura cewa yawancin abubuwan suna mutu da sauri) yana taimaka wajen tunani game da tsoffin tsaffukan alaken da yawan GC (rage allocations, musamman tsaffukan alaken ɗan gida, yana rage yawan GC).

**Stack da heap** bambanci (value types akan stack, reference objects akan heap) yana haɗa ga value/reference type tsarin.

A mahimmancin gida, fahimtar **`IDisposable`/`Dispose()` da bayanin `using`** ita ce mahimmanca da aminci: GC yana sarrafa *alaken* amma ba ba-sarraffaffiyar alaki* (filen handles, database connections, sockets), waɗanda suna buƙatar dawo daidai ta hanyar `using` — rashin dawo da waɗannan abubuwan yana haifar kuɗi na alaken (rashin daidai na gaskiya a kasusuwa).

Da kalau mahimmanci ita ce ganowa cewa **kuɗi na alaken yanzu iya faruwa** duk da GC, daga watazon references (haɗa caches, ba-waccan event handlers waɗanda ke tsare subscribers — girki na C# na gida).

Fahimtar GC's generational tsarin, tsarin sarraffaffiyar alaken (`IDisposable`/`using`), da abubuwan da ke haifar kuɗi ita ce mahimmanci don rubutu saurin, kuɗi na banza C#, musamman a aikace-aikacen da ke yana nan — yana sanya ita ilimin mahimmanci waɗanda ke bambanta masu bincike waɗanda zasu iya gina aikace-aikace na .NET da ke aiki daidai, kuma yana jiya-jiya na gabatarwa interview ne.