Stack vs heap mental model in C Sharp (C#)

Introduction

Understanding stack and heap helps you know where your data lives in memory. This makes your programs faster and less buggy.

When you want to understand why some variables disappear quickly and others stay longer.

When you want to know why some data is fast to access and some is slower.

When debugging memory errors or performance issues in your program.

When deciding how to store data: small temporary values or big objects.

When learning how C# manages memory automatically.

Syntax

C Sharp (C#)

public class StackVsHeapExample
{
    public void RunExample()
    {
        int number = 42; // Stored on stack
        Person person = new Person("Alice"); // Reference stored on stack, object on heap
        person.Name = "Bob"; // Modifies object on heap
    }
}

public class Person
{
    public string Name;
    public Person(string name)
    {
        Name = name;
    }
}

Value types like int are stored on the stack.

Reference types like Person have their reference on the stack but the actual object lives on the heap.

Examples

Value types copy the data, reference types copy the reference.

C Sharp (C#)

int x = 10; // x is on stack
int y = x; // y is a copy on stack

Person p1 = new Person("Anna"); // p1 reference on stack
Person p2 = p1; // p2 points to same object on heap

Arrays are reference types, so the array data is on the heap.

C Sharp (C#)

int[] numbers = new int[3] {1, 2, 3}; // array object on heap, reference on stack

numbers[0] = 10; // modifies heap data

Local variables live on the stack and disappear when method ends.

C Sharp (C#)

void Method()
{
    int localVar = 5; // localVar on stack
    Person localPerson = new Person("Eve"); // reference on stack, object on heap
} // localVar and reference disappear here, object on heap is garbage collected later

Objects on heap stay until no references point to them.

C Sharp (C#)

Person person = null; // reference on stack, no object yet
person = new Person("John"); // object created on heap
person = null; // reference cleared, object eligible for garbage collection

Sample Program

This program shows how value types (int) and reference types (Person) behave differently in memory. Changing the int inside the method does not affect the original because it's a copy on the stack. Changing the Person's name affects the original object on the heap.

C Sharp (C#)

using System;

public class StackVsHeapExample
{
    public static void Main()
    {
        int stackNumber = 100; // Stored on stack
        Console.WriteLine($"Stack number before change: {stackNumber}");

        Person heapPerson = new Person("Alice"); // Reference on stack, object on heap
        Console.WriteLine($"Person name before change: {heapPerson.Name}");

        ChangeValues(stackNumber, heapPerson);

        Console.WriteLine($"Stack number after change: {stackNumber}");
        Console.WriteLine($"Person name after change: {heapPerson.Name}");
    }

    public static void ChangeValues(int number, Person person)
    {
        number = 200; // Changes local copy on stack
        person.Name = "Bob"; // Changes object on heap
    }
}

public class Person
{
    public string Name;
    public Person(string name)
    {
        Name = name;
    }
}

Important Notes

Stack operations are very fast because they use simple push/pop.

Heap memory is managed by the garbage collector in C#.

Common mistake: expecting changes to value types inside methods to affect the original variable.

Use stack for small, short-lived data; use heap for objects that need to live longer or be shared.

Summary

Stack stores value types and references; it is fast and temporary.

Heap stores objects; it is slower but holds data longer.

Understanding this helps write efficient and bug-free C# programs.