Hoe werken klassen, constructors en properties?

Question

Accepted Answer

**Klassen** zijn de basis van C#'s object-georiënteerde model — blauwdrukken voor objecten, met **constructors** (initialiseren van objecten) en **properties** (gecontroleerde toegang tot gegevens). C#'s property-syntaxis is een kenmerkende, elegante functie.

## Een klasse met constructor en properties

```csharp
public class Person
{
    // auto-implemented PROPERTY — encapsulated access with get/set
    public string Name { get; set; }
    public int Age { get; private set; }      // settable only within the class
    public string Email { get; init; }          // set only during initialization (C# 9)

// CONSTRUCTOR
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

public string Greet() => $"Hi, I'm {Name}";   // a method
}

var person = new Person("Ann", 30);    // create an instance
person.Name = "Bob";                     // set a property
Console.WriteLine(person.Greet());
```

## Properties — encapsulation gemaakt elegant

```csharp
// auto-property (the common case) — compiler generates the backing field
public string Name { get; set; }

// property with custom logic
private decimal _balance;
public decimal Balance
{
    get => _balance;
    set => _balance = value >= 0 ? value : throw new ArgumentException();   // validation
}

// expression-bodied / computed property
public string FullName => $"{First} {Last}";   // read-only, computed
```

**Properties** zien eruit als velden maar zijn eigenlijk methoden (`get`/`set`) — die encapsulation bieden (gecontroleerde toegang, validatie, berekende waarden) met schone syntaxis. Auto-properties (`{ get; set; }`) behandelen het gangbare geval zonder boilerplate.

## Object initializers en moderne functies

```csharp
var p = new Person("Ann", 30) { Email = "a@x.com" };   // object initializer

// primary constructor (C# 12) — concise constructor parameters
public class Point(int x, int y)
{
    public int X { get; } = x;
}
```

## Waarom het belangrijk is

Klassen, constructors en properties zijn de basis van object-georiënteerde C# — vrijwel alle C# code is georganiseerd in klassen, dus het begrijpen ervan is essentieel voor elke C# ontwikkeling.

Weten hoe je klassen met constructors (initialiseren van objecten) en methoden definieert, is fundamenteel, maar C#'s **properties** zijn een bijzonder belangrijke en kenmerkende functie die het waard is goed begrepen te worden.

Properties bieden **encapsulation** elegant — ze zien eruit als velden maar zijn eigenlijk `get`/`set` methoden, waarmee gecontroleerde toegang, validatie, berekende waarden en access modifiers (zoals `private set` of `init`-only) mogelijk zijn terwijl de syntaxis schoon blijft. **Auto-properties** (`{ get; set; }`) behandelen het gangbare geval zonder enige boilerplate, waardoor encapsulation moeiteloos wordt (in tegenstelling tot talen waar je expliciete getter/setter methoden schrijft).

Begrijpen hoe properties werken (auto-properties, aangepaste logica, berekende/read-only, `init`-only voor immutability), constructors, object initializers en moderne conventies (primary constructors) is kern-, alledaagse kennis voor het schrijven van goed ingekapselde C# klassen.

Omdat klassen hoe je gegevens en gedrag in C# applicaties modelleert, en omdat properties de idiomatische, elegante manier zijn waarop C# encapsulation afhandelt (een kenmerkende taalfunctie die constant gebruikt wordt), het beheersen van deze — vooral het property systeem — is fundamenteel, essentieel materiaal voor effectieve object-georiënteerde C# ontwikkeling.