C# Academy · Leçon

Encapsulation et invariants

Masquez l’état interne, exposez des opérations sûres et préservez les invariants de la classe (par exemple un solde non négatif ou des valeurs dans une plage valide).

Encapsulation et invariants est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. 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 3 leçons au total.

Vue d’ensemble de l’encapsulation

Objectif : protéger l’état de votre objet’.

Encapsulation : masquer les fields et exposer des APIs sûres
Invariant : règle qui est toujours vraie
Valider dans les constructeurs, les accesseurs et les méthodes

Interface en lecture seule

Gardez les fields privés. Fournissez aux appelants une property en lecture seule et des opérations sûres.

using System;

// Expose read-only view; mutate via methods only
public class Counter
{
  private int _value;          // hidden state
  public int Value             // read-only to callers
  {
    get { return _value; }
    private set { _value = value; } // keep setter private
  }

  public void Increment()
  {
    Value = Value + 1;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Counter c = new Counter();
    c.Increment();
    c.Increment();
    Console.WriteLine("Value = " + c.Value);
  }
}

Protections des constructeurs

Les constructeurs définissent l’état requis. Protégez-vous contre les entrées non valides afin que les objets soient valides dès leur création.

using System;

// Enforce rules early (constructor guard)
public class User
{
  public string Name { get; private set; }
  public int Age { get; private set; }

  public User(string name, int age)
  {
    if (string.IsNullOrEmpty(name)) throw new ArgumentException("name");
    if (age < 0) throw new ArgumentOutOfRangeException("age");
    Name = name;
    Age = age;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    try
    {
      User u = new User("Ada", 28);
      Console.WriteLine(u.Name + " (" + u.Age + ")");
    }
    catch (Exception ex)
    {
      Console.WriteLine("Error: " + ex.Message);
    }
  }
}

Invariant en pratique

Définissez un invariant (par exemple, Balance ≥ 0) et faites-le respecter dans les accesseurs et les méthodes.

using System;

// Invariant: Balance >= 0 at all times
public class BankAccount
{
  private decimal _balance;

  public decimal Balance
  {
    get { return _balance; }
    private set
    {
      if (value < 0) throw new InvalidOperationException("Balance would be negative");
      _balance = value;
    }
  }

  public BankAccount(decimal opening)
  {
    if (opening < 0) throw new ArgumentOutOfRangeException("opening");
    _balance = opening;
  }

  public void Deposit(decimal amount)
  {
    if (amount <= 0) throw new ArgumentOutOfRangeException("amount");
    Balance = Balance + amount;
  }

  public bool TryWithdraw(decimal amount)
  {
    if (amount <= 0) return false;
    if (Balance - amount < 0) return false;
    Balance = Balance - amount;
    return true;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    BankAccount a = new BankAccount(50m);
    a.Deposit(20m);
    bool ok = a.TryWithdraw(100m); // fails, invariant protected
    Console.WriteLine("ok=" + ok + " balance=" + a.Balance);
  }
}

Protéger les collections

N’exposez pas directement les listes ou tableaux internes. Renvoyez une copie (ou une vue en lecture seule) pour protéger les invariants.

using System;
using System.Collections.Generic;

public class Tags
{
  private readonly List<string> _items = new List<string>();

  public void Add(string tag)
  {
    if (string.IsNullOrWhiteSpace(tag)) return;
    _items.Add(tag.Trim());
  }

  // Expose a copy so callers cannot mutate internal list
  public List<string> GetAllCopy()
  {
    return new List<string>(_items);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Tags t = new Tags();
    t.Add(" apple ");
    t.Add("banana");
    List<string> view = t.GetAllCopy();
    view.Add("hacker"); // modifies the copy only
    Console.WriteLine("copy count=" + view.Count);
    Console.WriteLine("original count=" + t.GetAllCopy().Count);
  }
}

Conseils sur l’encapsulation

Liste de vérification :

Fields privés ; properties et méthodes publiques.
Validez dans le constructeur et les accesseurs.
Préservez les invariants après chaque appel.
Ne laissez pas échapper les collections internes.

Principe de l’encapsulation

Vérification rapide : quel choix préserve le mieux l’encapsulation et l’invariant d’une classe ?

Récapitulatif

Récapitulatif : encapsulez avec des fields privés et des APIs validées. Définissez un invariant et faites-le respecter dans les constructeurs, les accesseurs et les méthodes. Ne laissez jamais échapper les collections internes.

Questions Fréquemment Posées

La leçon « Encapsulation et invariants » est-elle gratuite ?

Oui — le texte complet de « Encapsulation et invariants » 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Encapsulation et invariants » ?

Masquez l’état interne, exposez des opérations sûres et préservez les invariants de la classe (par exemple un solde non négatif ou des valeurs dans une plage valide). 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 3.

Combien de temps prend la leçon « Encapsulation et invariants » ?

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

Champs, propriétés automatiques et initialiseurs d’objets
Constructeurs et membres statiques
Encapsulation et invariants

← Retour à C# Academy