Les records (C# 9+) sont un moyen concis de définir des types qui sont principalement des conteneurs de données immuables avec égalité basée sur les valeurs. Ils génèrent automatiquement le code passe-partout (constructeur, égalité, ToString, etc.), ce qui les rend idéaux pour les DTOs, les valeurs de domaine et la modélisation de données.
// one line generates: constructor, properties, equality, ToString, deconstruction
public record Person(string Name, int Age);
var p1 = new Person("Ann", 30);
p1.Name; // "Ann" (read-only property)
Console.WriteLine(p1); // Person { Name = Ann, Age = 30 } — ToString generated
La syntaxe positionnelle record Person(string Name, int Age) génère tout — propriétés, constructeur, ToString, égalité, déconstruction — éliminant le code passe-partout qu'une classe ordinaire nécessiterait.
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)
Contrairement aux classes (qui comparent par identité de référence), les records comparent par valeur — deux records ayant les mêmes valeurs de propriétés sont égaux. C'est exactement ce que vous voulez pour les objets de données.
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 }
Les records sont immuables par défaut, et l'expression with crée une copie modifiée (mutation non-destructive) — idéale pour travailler avec des données immuables.
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)
Les records sont une fonctionnalité C# moderne importante (C# 9+) qui rend la définition de types de données immuables concise et correcte, donc les comprendre est précieux pour le développement C# moderne.
Leurs avantages clés répondent à des besoins réels : ils éliminent le code passe-partout (génération automatique de constructeurs, propriétés, ToString, égalité et déconstruction à partir d'une déclaration d'une ligne — par rapport au code substantiel qu'une classe ordinaire nécessite), et ils fournissent l'égalité basée sur les valeurs (deux records ayant des propriétés égales sont égaux, contrairement aux classes qui comparent par référence) — qui est exactement le comportement que vous voulez pour les objets de données, DTOs et valeurs de domaine, et que les classes font mal par défaut.
Les records sont aussi immuables par défaut avec l'élégante expression with pour la mutation non-destructive (création de copies modifiées), soutenant le style immutable et fonctionnel qui est de plus en plus favorisé pour un code plus sûr et plus prévisible.
Comprendre les records — la syntaxe concise, l'égalité par valeur, l'immuabilité avec with, et les record structs — est précieux pour écrire du C# moderne et propre, car ce sont le moyen idiomatique de modéliser les données (DTOs, modèles API, objets valeur, état immutable) et sont largement utilisés dans les bases de code actuelles.
Savoir quand utiliser un record (données immuables avec sémantique de valeur) par rapport à une classe (objets mutables avec identité et comportement riche) reflète une maîtrise du C# moderne.
Puisque les records simplifient dramatiquement la modélisation de données tout en fournissant l'égalité correcte et l'immuabilité — des besoins communs qui étaient autrefois laborieux et sujets aux erreurs — ce sont une fonctionnalité importante et fréquemment utilisée qui est une marque du code C# moderne et propre.
Une bibliothèque de questions d'entretien IT avec des réponses détaillées — du Junior au Senior.
Faire un don