0Pricing
C# Academy · Leçon

Modèles d’objets immuables

Concevez des objets qui ne changent plus après leur création.

Modèles d’objets immuables est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Concevoir des objets immuables

Un objet immuable ne change jamais après sa construction. L’immuabilité élimine toute une catégorie de bogues liés à l’état modifiable partagé et permet de transmettre et de mettre en cache les objets en toute sécurité.

Propriétés accessibles uniquement en lecture

La propriété immuable la plus simple est accessible uniquement en lecture et affectée une seule fois depuis un constructeur.

using System;

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

var p = new Point(3, 4);
Console.WriteLine(p.X + "," + p.Y); // 3,4

init pour la syntaxe des initialiseurs

Utilisez des propriétés init lorsque vous voulez l’immuabilité tout en conservant la syntaxe pratique des initialiseurs d’objet.

using System;

class Color {
    public int R { get; init; }
    public int G { get; init; }
    public int B { get; init; }
}

var c = new Color { R = 255, G = 128, B = 0 };
Console.WriteLine(c.R + "," + c.G + "," + c.B); // 255,128,0

required pour les champs obligatoires

Associez required et init afin que les champs essentiels ne puissent être oubliés ni modifiés.

using System;

class Money {
    public required decimal Amount { get; init; }
    public required string Currency { get; init; }
}

var m = new Money { Amount = 9.99m, Currency = "USD" };
Console.WriteLine(m.Amount + " " + m.Currency); // 9.99 USD

Retourner de nouveaux objets plutôt que modifier l’existant

Les types immuables exposent les opérations de « modification » sous forme de méthodes qui renvoient une nouvelle instance, en laissant l’originale intacte.

using System;

class Point {
    public int X { get; init; }
    public int Y { get; init; }
    public Point Move(int dx, int dy) => new Point { X = X + dx, Y = Y + dy };
}

var a = new Point { X = 1, Y = 1 };
var b = a.Move(2, 3);
Console.WriteLine(a.X + "," + a.Y + " -> " + b.X + "," + b.Y); // 1,1 -> 3,4

Collections immuables

Pour les champs contenant des collections, stockez une collection immuable ou en lecture seule afin que son contenu ne puisse pas être modifié via l’objet.

using System;
using System.Collections.Immutable;

class Team {
    public ImmutableList<string> Members { get; init; } = ImmutableList<string>.Empty;
}

var t = new Team { Members = ["Ada", "Lin"] };
var t2 = new Team { Members = t.Members.Add("Sam") };
Console.WriteLine(t.Members.Count + " " + t2.Members.Count); // 2 3

Copie défensive

Si vous devez accepter une collection modifiable, copiez-la lors de son entrée afin que les modifications externes ne puissent pas se propager.

using System;
using System.Collections.Generic;
using System.Linq;

class Snapshot {
    private readonly int[] data;
    public Snapshot(IEnumerable<int> source) => data = source.ToArray();
    public IReadOnlyList<int> Data => data;
}

var list = new List<int> { 1, 2, 3 };
var snap = new Snapshot(list);
list.Add(4); // does not affect snap
Console.WriteLine(snap.Data.Count); // 3

Égalité par valeur

Les objets immuables nécessitent souvent une égalité fondée sur les valeurs : deux instances contenant les mêmes données sont considérées comme égales. Les enregistrements l’offrent automatiquement ; les classes nécessitent des redéfinitions.

using System;

record Coord(int X, int Y);

Console.WriteLine(new Coord(1, 2) == new Coord(1, 2)); // True

Sécurité des threads sans effort

Comme les objets immuables ne changent jamais, ils sont intrinsèquement sûrs à partager entre threads sans verrous.

using System;

class ReadonlyConfig {
    public required string Env { get; init; }
}

var cfg = new ReadonlyConfig { Env = "prod" };
// safe to read from many threads without synchronization
Console.WriteLine(cfg.Env); // prod

Champs readonly et structures

Utilisez des champs readonly et une readonly struct pour imposer l’immuabilité des types valeur au niveau des champs.

using System;

readonly struct Vector {
    public readonly double X, Y;
    public Vector(double x, double y) { X = x; Y = y; }
    public double Length => Math.Sqrt(X * X + Y * Y);
}

Console.WriteLine(new Vector(3, 4).Length); // 5

Mise en pratique

Un type totalement immuable associant required, init, l’égalité par valeur et une méthode de mise à jour qui ne modifie pas l’objet.

using System;

record Account(string Id, decimal Balance) {
    public Account Deposit(decimal amount) => this with { Balance = Balance + amount };
}

var a = new Account("A1", 100m);
var b = a.Deposit(50m);
Console.WriteLine(a.Balance + " -> " + b.Balance); // 100 -> 150

Vérification rapide

Vérifiez le principe de la mise à jour immuable.

Récapitulatif

Vous avez appris des modèles pour créer des objets immuables.

  • Utilisez des propriétés accessibles uniquement en lecture ou des propriétés init, ainsi que required pour les données obligatoires.
  • Modélisez les modifications avec des méthodes qui renvoient de nouvelles instances.
  • Stockez des collections immuables ou copiées de manière défensive.
  • Les enregistrements fournissent l’égalité par valeur et les copies with ; l’immuabilité garantit la sécurité des threads.

Questions Fréquemment Posées

La leçon « Modèles d’objets immuables » est-elle gratuite ?

Oui — le texte complet de « Modèles d’objets immuables » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèles d’objets immuables » ?

Concevez des objets qui ne changent plus après leur création. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Modèles d’objets immuables » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Accesseurs init uniquement
  2. Le modificateur required
  3. Modèles d’objets immuables
  4. Expressions with sur les enregistrements
← Retour à C# Academy