Memory Management & Garbage Collector Internals

using System;

class Program
{
    // A class is a REFERENCE type — its objects live on the heap.
    class Box { public int Value; }

    static void Main()
    {
        // VALUE types (int, double, bool, struct) hold their data DIRECTLY.
        // For a local like this, the value sits on the STACK — fast, automatic.
        int a = 10;
        int b = a;        // b gets a COPY of a's value
        b = 99;           // changing b does NOT touch a
        Console.WriteLine($"a = {a}, b = {b}"
...

using System;

class Program
{
    static void Main()
    {
        // The GC sorts objects into 3 GENERATIONS by how long they survive.
        // Gen 0 = brand new, Gen 1 = survived once, Gen 2 = long-lived.
        var obj = new byte[1000];   // a fresh object starts in Gen 0

        Console.WriteLine($"Just allocated: Gen {GC.GetGeneration(obj)}");   // Gen 0

        // A Gen 0 collection promotes survivors to Gen 1.
        GC.Collect(0);
        Console.WriteLine($"After Gen 0 GC: Gen {G
...

using System;

class Program
{
    static void Main()
    {
        // 🎯 YOUR TURN — measure how much memory a big array costs.
        // GC.GetTotalMemory(false) returns the bytes the GC currently tracks.

        // 1) Read the memory BEFORE allocating anything.
        long before = GC.GetTotalMemory(false);   // 👉 already done for you
        Console.WriteLine($"Before: {before / 1024} KB");

        // 2) Allocate an array of 1,000,000 ints (about 4 MB).
        int[] big = new int[___];
...

using System;

class Program
{
    static void Main()
    {
        // Objects of 85,000 bytes OR MORE go on the LARGE OBJECT HEAP (LOH).
        // The LOH is collected only with Gen 2 and is NOT compacted by default,
        // so it can fragment — leave gaps that waste memory.

        // A small array stays on the normal heap, starting in Gen 0.
        var small = new byte[1000];
        Console.WriteLine($"Small array (1 KB): Gen {GC.GetGeneration(small)}");   // Gen 0

        // A large 
...

using System;

// IDisposable is the contract for DETERMINISTIC cleanup of resources the GC
// can't see (files, sockets, DB connections). You decide exactly WHEN it runs.
class FileLogger : IDisposable
{
    public FileLogger(string path)
    {
        Console.WriteLine($"Opened log file: {path}");   // pretend we opened a file
    }

    public void Write(string message)
    {
        Console.WriteLine($"LOG: {message}");
    }

    // Dispose() is where you release the resource right away.
  
...

using System;

// 🎯 YOUR TURN — make this class clean up properly, then use it safely.
class DbConnection : ___          // 👉 implement the interface  IDisposable
{
    public DbConnection()
    {
        Console.WriteLine("Connection opened");
    }

    // 1) Implement Dispose() so it prints the close message.
    public void Dispose()
    {
        Console.WriteLine(___);    // 👉 print  "Connection closed (Dispose ran)"
    }
}

class Program
{
    static void Main()
    {
        // 2) Wr
...

using System;

// A FINALIZER (~ClassName) runs when the GC collects the object — but you
// CANNOT control WHEN that happens, so it's the wrong tool for timely cleanup.
class Resource : IDisposable
{
    private bool disposed = false;

    public void Use() => Console.WriteLine("Using the resource");

    // The dispose pattern: free things NOW, and skip the finalizer afterwards.
    public void Dispose()
    {
        if (disposed) return;
        Console.WriteLine("Dispose: cleaned up immedia
...

using System;

// "Managed memory leak": an object stays reachable, so the GC never frees it.
// The two classic causes are undetached event handlers and static collections.
class Publisher
{
    public event EventHandler? OnTick;   // long-lived publisher
    public void Tick() => OnTick?.Invoke(this, EventArgs.Empty);
}

class Subscriber
{
    public Subscriber(Publisher p)
    {
        // The publisher now holds a reference to THIS subscriber via the handler.
        // If we never detach, t
...