Constructors en properties in C#

Het probleem met losse velden

In de vorige post hadden we publieke velden op onze klasse. Dat werkt, maar heeft een nadeel: niets verhindert dat iemand een ongeldige waarde invult, zoals een lege laagnaam of een negatief getal. Properties en constructors lossen dit op.

Constructor: initialisatie bij aanmaak

Een constructor is een speciale methode die automatisch wordt aangeroepen als je een object aanmaakt met new. De naam is hetzelfde als de klasse:

class Laag
{
    public string Naam;
    public bool IsZichtbaar;

    // Constructor
    public Laag(string naam)
    {
        Naam = naam;
        IsZichtbaar = true;  // standaardwaarde
    }
}

// Aanmaken — naam is verplicht
Laag muurLaag = new Laag("Muren");
Console.WriteLine(muurLaag.Naam);       // Muren
Console.WriteLine(muurLaag.IsZichtbaar); // True

Properties: gecontroleerde toegang

Een property ziet eruit als een veld, maar heeft een get (lezen) en optioneel een set (schrijven) accessor. Je kunt validatie inbouwen in de setter:

class Laag
{
    // Privaat opslagveld
    private string _naam = "";

    // Publieke property
    public string Naam
    {
        get { return _naam; }
        set
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Laagnaam mag niet leeg zijn.");
            _naam = value.Trim();
        }
    }

    public bool IsZichtbaar { get; set; } = true;  // auto-property met standaardwaarde
}

Auto-properties (de meest gebruikte schrijfwijze)

Als je geen validatie nodig hebt, gebruik je de korte notatie:

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

    public Punt(double x, double y, double z)
    {
        X = x;
        Y = y;
        Z = z;
    }

    public double Afstand(Punt ander)
    {
        double dx = X - ander.X;
        double dy = Y - ander.Y;
        double dz = Z - ander.Z;
        return Math.Sqrt(dx*dx + dy*dy + dz*dz);
    }
}

var p1 = new Punt(0, 0, 0);
var p2 = new Punt(3, 4, 0);
Console.WriteLine(p1.Afstand(p2));  // 5

Readonly property (alleen lezen van buiten)

class Cirkel
{
    public double Straal { get; private set; }  // privé setter: alleen de klasse kan wijzigen

    public Cirkel(double straal) => Straal = straal;

    public double Omtrek => 2 * Math.PI * Straal;  // berekende property (geen setter)
    public double Oppervlakte => Math.PI * Straal * Straal;
}

var c = new Cirkel(5.0);
Console.WriteLine(c.Omtrek);      // 31.41...
Console.WriteLine(c.Oppervlakte); // 78.53...
// c.Straal = 10;  ← compiler-fout: setter is privé

Samenvatting

• Constructor — verplichte initialisatie bij aanmaak, voorkomt "halve objecten"
• Property met validatie — beschermt de data-integriteit
• Auto-property — korte, nette schrijfwijze als validatie niet nodig is
• Berekende property — geen opgeslagen waarde, altijd berekend bij opvragen

In de volgende post leren we arrays, lijsten en woordenboeken — de opslagstructuren van C#.

The problem with loose fields

In the previous post we had public fields on our class. That works, but has a downside: nothing prevents someone from assigning an invalid value, like an empty layer name or a negative number. Properties and constructors solve this.

Constructor: initialisation at creation

class Layer
{
    public string Name;
    public bool IsVisible;

    public Layer(string name)
    {
        Name = name;
        IsVisible = true;
    }
}

Layer wallLayer = new Layer("Walls");
Console.WriteLine(wallLayer.Name);       // Walls
Console.WriteLine(wallLayer.IsVisible);  // True

Properties: controlled access

class Layer
{
    private string _name = "";

    public string Name
    {
        get { return _name; }
        set
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Layer name cannot be empty.");
            _name = value.Trim();
        }
    }

    public bool IsVisible { get; set; } = true;
}

Auto-properties (the most common form)

class Point
{
    public double X { get; set; }
    public double Y { get; set; }
    public double Z { get; set; }

    public Point(double x, double y, double z)
    {
        X = x; Y = y; Z = z;
    }

    public double DistanceTo(Point other)
    {
        double dx = X - other.X, dy = Y - other.Y, dz = Z - other.Z;
        return Math.Sqrt(dx*dx + dy*dy + dz*dz);
    }
}

var p1 = new Point(0, 0, 0);
var p2 = new Point(3, 4, 0);
Console.WriteLine(p1.DistanceTo(p2));  // 5

Readonly property

class Circle
{
    public double Radius { get; private set; }
    public Circle(double radius) => Radius = radius;
    public double Circumference => 2 * Math.PI * Radius;
    public double Area => Math.PI * Radius * Radius;
}

var c = new Circle(5.0);
Console.WriteLine(c.Circumference);  // 31.41...
Console.WriteLine(c.Area);           // 78.53...

In the next post we learn arrays, lists and dictionaries — C#'s storage structures.