OOP — Properties: get en set

Waarom properties?

In de vorige lessen gebruikten we al auto-properties: public string Naam { get; set; }. Dat werkt prima, maar heeft één nadeel: iedereen kan zomaar elke waarde instellen, ook ongeldige.

Stel: een persoon kan nooit een negatieve leeftijd hebben. Met een gewone auto-property is dit toegestaan:

Persoon p = new Persoon();
p.Leeftijd = -5;  // Dit kan! Maar het slaat nergens op...

Met een volledige property kan je dit voorkomen door validatie in te bouwen.

Stap 1 — Auto-property (de eenvoudige vorm)

Je kent dit al: de kortste schrijfwijze voor een eigenschap.

public class Persoon
{
    public string Naam     { get; set; }
    public int    Leeftijd { get; set; }
}

Show image

• get → lezen is toegestaan (van buiten naar binnen)
• set → schrijven is toegestaan (van buiten naar binnen)

Gebruik auto-properties als je geen validatie nodig hebt.

Stap 2 — Volledige property met backing field

Wanneer je wil controleren welke waarden toegestaan zijn, gebruik je een backing field — een private variabele die de echte waarde bijhoudt.

public class Persoon
{
    private int leeftijd;   // backing field: private, kleine letter

    public int Leeftijd     // property: public, hoofdletter
    {
        get { return leeftijd; }
        set
        {
            if (value >= 0)         // validatie
                leeftijd = value;   // pas bij geldige waarde opslaan
        }
    }
}

how image

Het sleutelwoord value staat voor de waarde die binnenkomt via de setter.

Voorbeeld:

Persoon p = new Persoon();
p.Leeftijd = 25;   // ✓ geldig → leeftijd = 25
p.Leeftijd = -3;   // ✗ ongezdig → genegeerd, leeftijd blijft 25
Console.WriteLine(p.Leeftijd);  // 25

Naamconventie: backing field vs property

Backing field: kleine letter, private → private int leeftijd;
Property: hoofdletter, public → public int Leeftijd { ... }
Ze mogen dezelfde naam hebben, alleen met verschillende hoofdletters!

Stap 3 — Private setter

Soms wil je dat een eigenschap van buitenaf alleen gelezen kan worden, maar intern (binnen de klasse) wel gewijzigd mag worden. Dit doe je met private set:

public class Spaarpot
{
    public int Saldo { get; private set; }   // van buiten: alleen lezen

    public Spaarpot(int beginBedrag)
    {
        Saldo = beginBedrag;   // intern instellen via constructor: mag
    }

    public void Storten(int bedrag)
    {
        Saldo += bedrag;       // intern wijzigen via methode: mag
    }
}

Van buiten de klasse:

Spaarpot s = new Spaarpot(50);
Console.WriteLine(s.Saldo);  // ✓ lezen mag → 50
s.Saldo = 9999;              // ✗ FOUT! setter is private
s.Storten(25);               // ✓ via methode aanpassen mag
Console.WriteLine(s.Saldo);  // 75

Vergelijking: de drie vormen

Volledig voorbeeld

using System;

namespace H9c
{
    public class Thermometer
    {
        private int temperatuur;   // backing field

        public int Temperatuur
        {
            get { return temperatuur; }
            set
            {
                if (value >= -273)    // absoluut nulpunt
                    temperatuur = value;
            }
        }

        public Thermometer(int beginTemperatuur)
        {
            Temperatuur = beginTemperatuur;   // gebruikt de setter met validatie
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            Thermometer t = new Thermometer(20);
            Console.WriteLine(t.Temperatuur);  // 20

            t.Temperatuur = 37;
            Console.WriteLine(t.Temperatuur);  // 37

            t.Temperatuur = -300;              // onder absoluut nulpunt → genegeerd
            Console.WriteLine(t.Temperatuur);  // 37 (onveranderd)
        }
    }
}

Uitvoer:

20
37
37

Stap voor stap: van auto-property naar volledige property

Wanneer je code evolueert, begin je eenvoudig en voeg je validatie toe als dat nodig blijkt:

Samenvatting

classDiagram
    class Thermometer {
        -int temperatuur
        +int Temperatuur
        +Thermometer(beginTemperatuur)
    }
    note for Thermometer "Backing field: private, kleine letter\nProperty: public, hoofdletter\nSetter valideert de waarde"

Onthoud

• Begin altijd met een auto-property — voeg validatie toe wanneer nodig
• Een backing field is altijd private en begint met een kleine letter
• Het sleutelwoord value in de setter is de waarde die ingesteld wordt
• Met private set kan alleen code binnen de klasse de waarde wijzigen

Veelgemaakte fout

public int Leeftijd
{
    get { return Leeftijd; }   // ❌ FOUT: roept zichzelf op → oneindige lus!
    set { Leeftijd = value; }  // ❌ FOUT: zelfde probleem
}

Gebruik altijd het backing field (kleine letter) in get/set:

private int leeftijd;          // backing field
public int Leeftijd
{
    get { return leeftijd; }   // ✅ GOED: leest het backing field
    set { leeftijd = value; }  // ✅ GOED: schrijft naar het backing field
}