Propriétés pour l'encapsulation

Fait partie de la section Programmation Orientée Objet du Journey C# de Coddy — leçon 32 sur 70.

Les propriétés sont l'outil principal pour implémenter l'encapsulation en C#. Au lieu d'exposer directement les champs, vous les enveloppez avec des propriétés qui contrôlent la manière dont les données sont accédées et modifiées.

Le modèle combine un champ privé avec une propriété publique qui inclut une validation ou une logique dans ses accesseurs :

public class Temperature
{
    private double celsius;
    
    public double Celsius
    {
        get { return celsius; }
        set
        {
            if (value < -273.15)
                celsius = -273.15;  // Minimum du zéro absolu
            else
                celsius = value;
        }
    }
}

Désormais, le code externe ne peut pas définir une température impossible. La propriété agit comme un garde-barrière, garantissant que votre objet reste toujours dans un état valide. C'est l'encapsulation en action : les données internes sont protégées tout en restant accessibles via une interface contrôlée.

Vous pouvez également utiliser des propriétés pour calculer des valeurs ou déclencher des effets secondaires :

public double Fahrenheit
{
    get { return celsius * 9 / 5 + 32; }
    set { celsius = (value - 32) * 5 / 9; }
}

Le monde extérieur voit deux propriétés, mais en interne, il n'y a qu'un seul champ. Les propriétés vous permettent de modifier les détails d'implémentation sans casser le code qui utilise votre classe — un avantage clé d'une encapsulation appropriée.

Défi

Facile

Construisons un système d'inventaire de produits qui utilise des propriétés pour protéger l'intégrité des données. Vous allez créer une classe où les prix ne peuvent jamais être négatifs et les quantités sont toujours maintenues dans des limites valides - démontrant ainsi comment les propriétés agissent comme des gardiens pour vos données.

Vous organiserez votre code sur deux fichiers :

Product.cs : Créez une classe Product dans l'espace de noms Inventory qui gère les informations sur les produits avec une validation via des propriétés. Votre produit a besoin de :
- Un champ privé price (decimal) avec une propriété publique Price qui garantit que le prix ne descend jamais en dessous de 0 - si quelqu'un essaie de définir un prix négatif, il doit être stocké comme 0 à la place
- Un champ privé quantity (int) avec une propriété publique Quantity qui maintient les valeurs entre 0 et 1000 - les valeurs inférieures à 0 deviennent 0, les valeurs supérieures à 1000 deviennent 1000
- Une propriété auto-implémentée publique Name (string)
- Une propriété calculée en lecture seule TotalValue qui retourne Price * Quantity
Incluez un constructeur qui accepte le nom, le prix et la quantité (dans cet ordre) et définit toutes les valeurs via les propriétés afin que la validation soit appliquée.
Program.cs : Dans votre fichier principal, créez un Product en utilisant les valeurs d'entrée. Tentez ensuite de modifier le prix et la quantité avec des valeurs d'entrée supplémentaires qui pourraient être invalides. Affichez l'état du produit après la création et après chaque modification pour voir comment les propriétés protègent les données.

Vous recevrez cinq entrées :

Nom du produit
Prix initial (decimal)
Quantité initiale (integer)
Nouveau prix à définir (decimal, peut être négatif)
Nouvelle quantité à définir (integer, peut être hors limites)

Affichez la sortie dans ce format :

After creation:
{Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
After modifications:
{Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}

Par exemple, si les entrées sont Laptop, 999.99, 50, -100, et 1500, la sortie devrait être :

After creation:
Laptop: Price=999.99, Qty=50, Total=49999.50
After modifications:
Laptop: Price=0, Qty=1000, Total=0

Remarquez comment le prix négatif est devenu 0 et la quantité de 1500 a été limitée à 1000. Vos propriétés protègent l'objet contre des états invalides - c'est l'encapsulation à l'œuvre !

Aide-mémoire

Les propriétés enveloppent des champs privés avec un accès contrôlé via les accesseurs get et set, permettant la validation et l'encapsulation :

public class Temperature
{
    private double celsius;
    
    public double Celsius
    {
        get { return celsius; }
        set
        {
            if (value < -273.15)
                celsius = -273.15;
            else
                celsius = value;
        }
    }
}

Les propriétés peuvent calculer des valeurs basées sur des champs internes :

public double Fahrenheit
{
    get { return celsius * 9 / 5 + 32; }
    set { celsius = (value - 32) * 5 / 9; }
}

Les propriétés en lecture seule omettent l'accesseur set, permettant uniquement la récupération de valeurs calculées ou stockées.

Essayez vous-même

using System;
using Inventory;

class Program
{
    public static void Main(string[] args)
    {
        // Lire les entrées
        string name = Console.ReadLine();
        decimal initialPrice = Convert.ToDecimal(Console.ReadLine());
        int initialQuantity = Convert.ToInt32(Console.ReadLine());
        decimal newPrice = Convert.ToDecimal(Console.ReadLine());
        int newQuantity = Convert.ToInt32(Console.ReadLine());

        // TODO: Créer un Product en utilisant les valeurs initiales
        
        // TODO: Afficher l'état du produit après la création
        Console.WriteLine("After creation:");
        // Format d'affichage : {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
        
        // TODO: Modifier le prix et la quantité avec les nouvelles valeurs
        
        // TODO: Afficher l'état du produit après les modifications
        Console.WriteLine("After modifications:");
        // Format d'affichage : {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
    }
}