C# — Immutabilité (Cours complet)

1. Qu’est-ce que l’immutabilité ?

Un objet immuable est un objet dont l’état ne peut plus changer après sa création.

Toute “modification” se fait en réalité en créant une nouvelle instance, l’ancienne restant intacte.

public record Person(string Name, int Age);

var p1 = new Person("Alice", 30);
var p2 = p1 with { Age = 31 }; // nouvelle instance

➡️ p1 n’est jamais modifié.

2. Pourquoi utiliser des objets immuables ?

✔ 2.1 Code plus simple et prévisible

Pas d’effet de bord : les objets ne changent jamais silencieusement.

✔ 2.2 Thread-safe naturellement

Les objets immuables peuvent être partagés entre threads sans locking.

✔ 2.3 Moins de bugs

Pas de variables modifiées “à distance”.

✔ 2.4 Compatibilité parfaite avec LINQ et programmation fonctionnelle

3. Comment créer un objet immuable en C#

3.1 Utiliser les `record`

public record Point(int X, int Y);

3.2 Utiliser des propriétés `init`

public class Settings {
    public int Limit { get; init; }
    public string Mode { get; init; }
}

3.3 Utiliser des champs `readonly`

public class Vector {
    public readonly double X;
    public readonly double Y;

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

3.4 Aucune méthode ne doit modifier l’objet

public Vector Move(double dx, double dy) =>
    new Vector(X + dx, Y + dy);

4. Exemples pratiques d’immutabilité

4.1 Exemple simple

public record User(string Name, int Age);

var u1 = new User("Bob", 20);
var u2 = u1 with { Age = 21 };

4.2 Exemple avancé : transformation de données

public record Order(int Id, decimal Price);

Order ApplyDiscount(Order order, decimal percent) =>
    order with { Price = order.Price * (1 - percent) };

5. Les faux objets immuables

5.1 Exposer un tableau → ❌ pas immuable

public class Wrong {
    public int[] Values { get; }

    public Wrong(int[] values) {
        Values = values; // fuite de référence
    }
}

var w = new Wrong(new int[]{1,2});
w.Values[0] = 99; // la classe n'est pas immuable !

5.2 Collections modifiables exposées → ❌ pas immuable

5.3 Struct mutable → ❌ pas immuable

public struct MutablePoint {
    public int X;
    public int Y;
}
// mutable = dangereux dans les API

6. Comment garantir l’immutabilité

Utiliser record autant que possible
Utiliser des propriétés init
Ne jamais exposer directement des tableaux ou collections internes
Utiliser ImmutableArray<T>, ImmutableList<T>
Ne fournir aucune méthode modifiant l'état interne

7. Immutabilité et multithreading

Les objets immuables sont naturellement thread-safe :

var config = new Config(port: 80);

// partagé entre threads → aucun problème

Pas besoin de verrouiller : l'objet ne change pas.

8. Immutabilité dans les API modernes

Records : conçus pour être immuables
LINQ : transformations immuables
System.Collections.Immutable : collections immuables
Pattern Matching : idéal avec structures immuables

9. Résumé

L’immutabilité est un concept essentiel pour écrire du code propre, robuste, thread-safe et facile à raisonner. C# fournit plusieurs outils pour la mettre en œuvre efficacement : records, init, readonly, etc.

C# — Immutabilité