Structs en C# – Différences avec les classes

En C#, class (classe) et struct (structure) sont deux types fondamentaux qui réunissent données et comportements. Bien qu’ils puissent sembler similaires au premier abord, ils diffèrent de manière significative en termes de gestion de la mémoire et d’utilisation prévue. Les types class se comportent comme des types référence, tandis que les types struct sont des types valeur.

Qu’est-ce qu’un Struct ?

Un struct est généralement utilisé pour représenter de petits ensembles de données simples et de courte durée de vie. Il est adapté à des scénarios tels qu’un point de coordonnées 2D ou une plage de dates. Par défaut, c’est un type valeur, ce qui signifie qu’en cas de copie, une nouvelle copie indépendante est créée.

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

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

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

Différences entre Struct et Class

Voici les différences les plus fondamentales entre struct et class :

• Catégorie de type : struct est un type valeur, class est un type référence.
• Mémoire : Les structures sont généralement stockées sur la pile (stack) ; les classes sur le tas (heap).
• Copie : Lorsqu’une structure est affectée, toutes les valeurs sont copiées. Pour les classes, seule la référence est copiée.
• Constructeur sans paramètre : Avant C# 10, les structures ne pouvaient pas définir de constructeur sans paramètre, alors que les classes le pouvaient.
• Héritage : Les structures ne peuvent pas hériter d’une autre structure ou classe, mais elles peuvent implémenter des interfaces.
• Valeurs null : Les structures ne sont pas null par défaut ; les structures nullables (Point?) sont autorisées. Les classes peuvent être null.

Comportement de copie

Lorsque les structures sont copiées, une nouvelle copie indépendante est créée. Pour les classes, seule la référence est copiée et les deux variables pointent vers le même objet.

Point p1 = new Point(10, 20);
Point p2 = p1; // copié
p2.X = 99;

Console.WriteLine(p1.X); // 10 (copie indépendante)
Console.WriteLine(p2.X); // 99

class Person
{
    public string Name { get; set; }
}

var p1 = new Person { Name = "John" };
var p2 = p1; // même référence
p2.Name = "Michael";

Console.WriteLine(p1.Name); // "Michael"
Console.WriteLine(p2.Name); // "Michael"

Types Référence et Types Valeur

En C#, les types sont divisés en deux grandes catégories : types valeur et types référence. Un struct est un type valeur : lorsqu’il est affecté à une variable ou passé en paramètre à une méthode, toutes les données sont copiées. Ainsi, les modifications apportées à une copie n’affectent pas l’autre. Une class est un type référence : lorsqu’elle est affectée à une variable, une référence pointant vers le même objet en mémoire est copiée. Par conséquent, une modification effectuée via une référence est visible par les autres références.

// Type valeur (struct)
Point p1 = new Point(1, 2);
Point p2 = p1;   // copie
p2.X = 99;
Console.WriteLine(p1.X); // 1
Console.WriteLine(p2.X); // 99

// Type référence (class)
Person a = new Person { Name = "Alice" };
Person b = a;    // même objet
b.Name = "Marie";
Console.WriteLine(a.Name); // Marie
Console.WriteLine(b.Name); // Marie

Quand utiliser Struct et quand utiliser Class ?

Utilisez struct pour de petits types de données, immuables (ou presque) et limités en comportement. Préférez class pour des objets plus grands, complexes, ayant une durée de vie plus longue et nécessitant l’héritage. Par exemple : points 3D, valeurs de couleur, plages de dates → struct ; client, produit, commande → class.

Exemple : Calcul avec Struct

public struct Point2D
{
    public int X { get; }
    public int Y { get; }

    public Point2D(int x, int y)
    {
        X = x;
        Y = y;
    }

    public double DistanceTo(Point2D other)
    {
        int dx = X - other.X;
        int dy = Y - other.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

class Program
{
    static void Main()
    {
        var p1 = new Point2D(0, 0);
        var p2 = new Point2D(3, 4);

        Console.WriteLine(p1.DistanceTo(p2)); // 5
    }
}

TL;DR