Records (C# 9+) är ett kortfattat sätt att definiera typer som i första hand är oföränderliga databärare med värdebaserad likhet. De auto-genererar boilerplate-kod (konstruktor, likhet, ToString, etc.), vilket gör dem idealiska för DTOs, domänvärden och datamodellering.
;
p1 = Person(, );
p1.Name;
Console.WriteLine(p1);
Den positionella syntaxen record Person(string Name, int Age) genererar allt — egenskaper, konstruktor, ToString, likhet, dekonstruktion — och eliminerar det boilerplate som en vanlig klass skulle behöva.
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)
Olikt klasser (som jämför efter referensidentitet) jämför records efter värde — två records med samma egenskapsvärden är lika. Detta är exakt vad du vill ha för dataobjekt.
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 är oföränderliga som standard, och with-uttrycket skapar en modifierad kopia (icke-destruktiv mutation) — idealiskt för att arbeta med oföränderlig data.
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 är en viktig modern C#-funktion (C# 9+) som gör det enkelt och korrekt att definiera oföränderliga datatyper, så att förstå dem är värdefullt för modern C#-utveckling.
Deras viktigaste fördelar löser verkliga behov: de eliminerar boilerplate-kod (auto-genererar konstruktorer, egenskaper, ToString, likhet och dekonstruktion från en en-rads deklaration — jämfört med den omfattande kod en vanlig klass kräver), och de ger värdebaserad likhet (två records med lika egenskaper är lika, till skillnad från klasser som jämför efter referens) — vilket är exakt det beteende du vill ha för dataobjekt, DTOs och domänvärden, och som klasser får fel på som standard.
Records är också oföränderliga som standard med det eleganta with-uttrycket för icke-destruktiv mutation (skapande av modifierade kopior), vilket stöder den oföränderliga, funktionella stil som blir allt vanligare för säkrare, mer förutsägbar kod.
Att förstå records — den kortfattade syntaxen, värdeljämhet, oföränderlighet med with, och record structs — är värdefullt för att skriva ren modern C#, eftersom de är det idiomatiska sättet att modellera data (DTOs, API-modeller, värdeobjekt, oföränderligt tillstånd) och används ofta i aktuella kodbaser.
Att veta när man ska använda en record (oföränderlig data med värdessemantik) jämfört med en klass (föränderliga objekt med identitet och rik beteende) återspeglar flytande med modern C#.
Eftersom records dramatiskt förenklar datamodellering samtidigt som de ger korrekt likhet och oföränderlighet — vanliga behov som var tråkiga och felbenägna innan — är de en viktig, ofta använd funktion som är ett kännetecken på modern, ren C#-kod.