Records vs Structs vs Classes en .Net 9

C# propose plusieurs façons de définir des types : Records, Structures et Classes. Chacun a ses propres qualités et limites. Dans cet article, je discuterai de chaque construction et vous aiderai à identifier celle à utiliser dans votre projet.

Definitions

Qu’es ce qu’une classe en C# ?

Une classe définit un objet de type référence, ce qui signifie que lorsqu’une instance de classe est créée, une référence à cet objet est créée et la référence est transmise plutôt que l’objet lui-même. Une classe peut également être considérée comme un modèle ou un type défini par l’utilisateur qui suit les principes orientés objet (POO) en encapsulant et en abstrayant les champs et les comportements.

Qu’es ce qu’une Struct en C# ?

Un (« un », « une » ? aucune idée 😀 ) Struct est un objet de type valeur, ce qui signifie que lorsqu’une instance de structure est créée, une copie de cette instance est créée et transmise, contrairement aux classes qui transmettent la référence réelle.

Qu’es ce qu’un Record en C# ?

Les Records sont des types immuables introduits dans C# 9.0. Ils proposent des déclarations de types avec une syntaxe simple et concise. Les Records sont des types référence, tout comme les classes. Cependant, comme les structures, elles disposent de fonctionnalités intégrées pour comparer et hacher des objets. Les enregistrements peuvent contenir des data members et aussi des members, tout comme les deux autres homologues.

Usage et fonctionnalités

Bien que les class, struct et records soient des déclarations de type, chacun vous aide dans des scénarios spécifiques. Regardons cela de plus près:

Class

Les classes sont le type le plus complexe et le plus riche en fonctionnalités. Ils remplissent les concepts de POO et proposent des constructeurs avec, et sans paramètres. Vous pouvez tirer parti de la création de types référence et de la mutabilité dans les objets de classe. De plus, vous pouvez rendre les propriétés et les champs immuables en lecture seule ou en init.

public class Student
{
    public string Name { get; }
    public int Semester { get; set; }

    public Student(string name, int semester)
    {
        Name = name;
        Semester = semester;
    }
 
    public void Greetings()
    {
        Console.WriteLine($"Hi, my name is {Name}.");
    }
}

// Usage
var s1 = new Student("Morgan", 4);
var s2 = s1;
s2.Semester= 6;
Console.WriteLine(s1.Semester); // output: 6
Console.WriteLine(s2.Semester); // output: 6

Dans l’exemple, nous définissons la valeur de s2.Semester sur 6. Cependant, la nouvelle valeur a également été définie sur s1.Semester puisque s2 est une référence à s1.

Les propriétés peuvent être rendues immuables avec init :

public class Student
{
    public string Name { get; init; }
...

Ou avec le mot clé readonly :

public class Student
{
    Public readonly string Name;

    public Student(string name)
    {
        Name = name;
    }
...

Usage des classes

Les classes sont idéales pour modéliser des objets de données complexes et des implémentations de méthodes. Ceci est activé car les classes exploitent complètement les principaux POO et parce que les données membres peuvent être modifiées. La seule limitation est que les classes conservent une surcharge pour conserver la référence des instances copiées.

Structs

Les Structs sont de simples types mutables qui utilisent une modification basée sur les valeurs. Cependant, il ne prend pas en charge l’héritage connu de la POO et est déclaré sealed par défaut. Les constructeurs sans paramètre ne sont pas non plus pris en charge.

public struct Point
{
    public double X { get; set; }
    public double Y { get; set; }

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

    public void Print()
    {
        Console.WriteLine($"X {X} , Y {Y}");
    }
}

// Usage
var p1 = new Point(3.2, 5.6);
var p2 = p1;
p2.Y= 6;
p1.Print(); // output: X 3.2 , Y 5.6
p2.Print(); // output: X 3.2 , Y 6

Comme le montre le résultat, définir la valeur de p2.Y sur 6 ne modifie que p2 et non p1.

Usage des Structs

Struct est idéal lorsque vous souhaitez déclarer des structures de données simples et légères. Tout comme l’exemple ci-dessus, le type requis pour un point, vous pouvez donc définir sa structure en éliminant la surcharge de référence supplémentaire. En d’autres termes, lorsque votre type doit implémenter la comparaison de base et le stockage de données, une structure peut vous aider à réduire le stockage supplémentaire.

Records

Les Records présentent de nombreux avantages des classes et des structs. Ce sont des types référence comme les classes et sont comparés par valeur, tout comme les structures. Les enregistrements prennent en charge l’héritage, mais ses instances sont immuables, nous ne pouvons donc pas modifier la valeur des parents.

public record Student(string Name, int Age)
{
    // Method to display a formatted string
    public string GetDetails()
    {
        return $"Student: {Name}, Age: {Age}";
    }
}

// Usage
var s1 = new Student("Alex", 25);
Console.WriteLine(s1.GetDetails());

Vous pouvez aussi simplement utiliser la méthode ToString() par défaut des records pour imprimer toutes les propriétés publiques :

Console.WriteLine(s1.ToString());

Usage des records

Les records entrent en jeu lorsque vous avez besoin de caractères pour une comparaison et une égalité basées sur des valeurs, telles que les DTO ou d’autres conceptions centrées sur les données. Votre code semble propre et concis car vous n’avez pas besoin de code passe-partout pour la déclaration de type dans les enregistrements C#.

Conclusion

C# propose différentes manières de déclarer des types. Nous avons exploré chacun d’eux en détail et trouvé lequel convient à quels scénarios:

• Les classes sont les plus courantes et les plus complexes, liées aux principes de la POO. Ils prennent en charge la modification basée sur les références et déclarent des objets mutables;
• Les structs sont une autre option en C#, qui sont des types valeur. Ils sont également mutables et légers, ce qui réduit les coûts de référencement;
• Enfin, les records sont des types de référence immuables et effectuent des comparaisons basées sur des valeurs.

Chacun d’eux a sa propre fonctionnalité pour ce qu’il est introduit dans l’écosystème C#.