Records (C# 9+) zijn een beknopte manier om typen te definiëren die voornamelijk immutable datadragers zijn met value-based equality. Ze genereren automatisch boilerplate (constructor, equality, ToString, enzovoort), waardoor ze ideaal zijn voor DTO's, domeinwaarden en datamodellering.
;
p1 = Person(, );
p1.Name;
Console.WriteLine(p1);
De positionele syntaxis record Person(string Name, int Age) genereert alles — properties, constructor, ToString, equality, deconstruction — waardoor de boilerplate die een gewone class nodig zou hebben, overbodig wordt.
var a = new Person("Ann", 30);
var b = new Person("Ann", 30);
a == b; // TRUE — records compare by VALUE (all properties equal)
// (a regular class would be FALSE here — classes compare by reference)
In tegenstelling tot classes (die vergelijken op basis van referentie-identiteit), vergelijken records op basis van waarde — twee records met dezelfde property-waarden zijn gelijk. Dit is precies wat je wilt voor data-objecten.
public record Person(string Name, int Age); // properties are init-only (immutable)
var p1 = new Person("Ann", 30);
var p2 = p1 with { Age = 31 }; // `with` creates a COPY with some properties changed
// p1 unchanged (immutable); p2 = Person { Name = Ann, Age = 31 }
Records zijn standaard immutable, en de with-expressie maakt een aangepaste kopie (niet-destructieve mutatie) — ideaal om met immutable data te werken.
public record class Ref(int X); // a reference type (default) with value equality
public record struct Val(int X); // a VALUE type record (C# 10)
Records zijn een belangrijke moderne C#-feature (C# 9+) die het definiëren van immutable datatypen beknopt en correct maakt, dus het begrijpen ervan is waardevol voor moderne C#-ontwikkeling.
Hun belangrijkste voordelen spelen in op echte behoeften: ze elimineren boilerplate (door automatisch constructors, properties, ToString, equality en deconstruction te genereren uit een declaratie van één regel — versus de aanzienlijke hoeveelheid code die een gewone class vereist), en ze bieden value-based equality (twee records met gelijke properties zijn gelijk, in tegenstelling tot classes die op referentie vergelijken) — wat precies het gedrag is dat je wilt voor data-objecten, DTO's en domeinwaarden, en wat classes standaard verkeerd doen.
Records zijn ook standaard immutable met de elegante with-expressie voor niet-destructieve mutatie (het maken van aangepaste kopieën), wat de immutable, functionele stijl ondersteunt die steeds meer de voorkeur krijgt voor veiligere, voorspelbaardere code.
Het begrijpen van records — de beknopte syntaxis, value equality, immutability met with, en record structs — is waardevol voor het schrijven van schone moderne C#, aangezien ze de idiomatische manier zijn om data te modelleren (DTO's, API-modellen, value objects, immutable state) en op grote schaal worden gebruikt in huidige codebases.
Weten wanneer je een record (immutable data met value-semantiek) versus een class (mutable objecten met identiteit en rijk gedrag) gebruikt, weerspiegelt vloeiendheid met moderne C#.
Omdat records datamodellering drastisch vereenvoudigen en tegelijkertijd correcte equality en immutability bieden — veelvoorkomende behoeften die voorheen omslachtig en foutgevoelig waren — zijn het een belangrijke, veelgebruikte feature die kenmerkend is voor moderne, schone C#-code.