References vs values: hoe C# met geheugen omgaat

Het geheugen in twee zones

C# gebruikt twee geheugengebieden:

• Stack — snel, klein, bewaard tijdelijk terwijl een methode loopt
• Heap — groter, bewaard objecten die langer leven

Value types: de kopie-wereld

Value types (zoals int, double, bool, struct) bewaren hun waarde rechtstreeks op de stack. Als je ze kopieert, maak je een echte kopie:

int a = 10;
int b = a;    // b is een KOPIE van a
b = 20;

Console.WriteLine(a);  // 10 — ongewijzigd!
Console.WriteLine(b);  // 20

Reference types: de verwijzings-wereld

Reference types (alle class-objecten) bewaren een verwijzing (adres) op de stack naar het object op de heap. Als je ze "kopieert", kopieer je alleen het adres:

class Punt { public double X; public double Y; }

Punt p1 = new Punt { X = 3, Y = 4 };
Punt p2 = p1;    // p2 wijst naar HETZELFDE object als p1!
p2.X = 99;

Console.WriteLine(p1.X);  // 99 — ook p1 is veranderd!

Echte kopie van een object maken

Voeg een kopieer-methode toe aan je klasse:

class Punt
{
    public double X { get; set; }
    public double Y { get; set; }

    public Punt Kopieer() => new Punt { X = this.X, Y = this.Y };
}

Punt p1 = new Punt { X = 3, Y = 4 };
Punt p2 = p1.Kopieer();  // echte kopie
p2.X = 99;

Console.WriteLine(p1.X);  // 3 — ongewijzigd

null: de lege referentie

Een reference type kan ook null zijn — een verwijzing naar niets. Dit is een veelvoorkomende oorzaak van fouten (NullReferenceException):

Punt? punt = null;

// Fout! Dit crasht:
// Console.WriteLine(punt.X);

// Veilige manier — controleer eerst:
if (punt != null)
    Console.WriteLine(punt.X);

// Of gebruik de null-conditionale operator:
Console.WriteLine(punt?.X);  // toont niets als punt null is

Strings zijn bijzonder

string is een reference type, maar gedraagt zich als een value type: een string is immutable (onveranderlijk). Elke bewerking geeft een nieuwe string terug:

string s1 = "AutoCAD";
string s2 = s1;
s2 = s2.ToUpper();

Console.WriteLine(s1);  // "AutoCAD" — ongewijzigd
Console.WriteLine(s2);  // "AUTOCAD"

In de volgende post leren we overerving en interfaces — het fundament van herbruikbare OOP-code.

Memory in two zones

C# uses two memory areas:

• Stack — fast, small, holds data temporarily while a method runs
• Heap — larger, holds objects that live longer

Value types: the copy world

int a = 10;
int b = a;    // b is a COPY of a
b = 20;

Console.WriteLine(a);  // 10 — unchanged!
Console.WriteLine(b);  // 20

Reference types: the pointer world

class Point { public double X; public double Y; }

Point p1 = new Point { X = 3, Y = 4 };
Point p2 = p1;    // p2 points to THE SAME object as p1!
p2.X = 99;

Console.WriteLine(p1.X);  // 99 — p1 changed too!

Creating a real copy

class Point
{
    public double X { get; set; }
    public double Y { get; set; }
    public Point Copy() => new Point { X = this.X, Y = this.Y };
}

Point p1 = new Point { X = 3, Y = 4 };
Point p2 = p1.Copy();  // real copy
p2.X = 99;
Console.WriteLine(p1.X);  // 3 — unchanged

null: the empty reference

Point? point = null;

// Safe check:
if (point != null)
    Console.WriteLine(point.X);

// Or use the null-conditional operator:
Console.WriteLine(point?.X);  // prints nothing if null

Strings are special

string is a reference type but behaves like a value type: strings are immutable. Every operation returns a new string:

string s1 = "AutoCAD";
string s2 = s1;
s2 = s2.ToUpper();

Console.WriteLine(s1);  // "AutoCAD" — unchanged
Console.WriteLine(s2);  // "AUTOCAD"

In the next post we learn inheritance and interfaces — the foundation of reusable OOP code.