Propriétés en lecture/écriture seule

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

Parfois, vous avez besoin de propriétés qui peuvent uniquement être lues ou uniquement être écrites. Vous pouvez contrôler cela en utilisant private sur des accesseurs individuels.

Une propriété en lecture seule possède un accesseur public, mais un mutateur privé (ou aucun mutateur) :

public class User
{
    public string Username { get; private set; }
    
    public User(string username)
    {
        Username = username;
    }
}

Le code externe peut lire Username, mais seule la classe elle-même peut le modifier. Cela est utile pour les valeurs qui doivent être définies une seule fois lors de la construction.

Une propriété en écriture seule possède un accesseur public, mais un accesseur privé :

public class Account
{
    public string Password { private get; set; }
    
    public bool ValidatePassword(string input)
    {
        return input == Password;
    }
}

Les propriétés en écriture seule sont rares, mais utiles pour les données sensibles comme les mots de passe, lorsque vous souhaitez accepter une saisie sans exposer la valeur stockée.

Vous pouvez également créer des propriétés véritablement en lecture seule avec uniquement un getter :

public class Circle
{
    public double Radius { get; }
    public double Area => Math.PI * Radius * Radius;
    
    public Circle(double radius)
    {
        Radius = radius;
    }
}

Les propriétés comportant uniquement get; ne peuvent être affectées que dans le constructeur ou lors de leur déclaration, ce qui les rend immuables après la création de l’objet.

Défi

Facile

Construisons un système de configuration sécurisé qui montre quand utiliser des propriétés en lecture seule et en écriture seule pour protéger les données sensibles.

Vous allez créer deux fichiers pour organiser votre code :

Config.cs : définissez une classe ServerConfig dans l’espace de noms Settings qui gère la configuration du serveur. Elle doit comporter :
- Une propriété en lecture seule ServerName (qui ne peut être définie que dans le constructeur)
- Une propriété en lecture seule Port avec un setter privé (définie via le constructeur)
- Une propriété en écriture seule ApiKey qui stocke une clé secrète en interne
- Une méthode ValidateApiKey(string key) qui renvoie true si la clé fournie correspond à celle stockée
- Un constructeur qui accepte le nom du serveur et le port
Program.cs : dans votre fichier principal, créez un objet ServerConfig à l’aide des valeurs saisies, définissez la clé API, puis validez-la par rapport à une clé de test.

Vous recevrez quatre entrées :

Nom du serveur
Numéro de port
Clé API à stocker
Clé API à valider

Affichez les détails du serveur et le résultat de la validation dans ce format :

Server: {ServerName}, Port: {Port}
API Key Valid: {True/False}

Par exemple, si les entrées sont MainServer, 8080, secret123 et secret123, la sortie devrait être :

Server: MainServer, Port: 8080
API Key Valid: True

Essayez vous-même

using System;
using Settings;

class Program
{
    public static void Main(string[] args)
    {
        // Lire les entrées
        string serverName = Console.ReadLine();
        int port = Convert.ToInt32(Console.ReadLine());
        string apiKeyToStore = Console.ReadLine();
        string apiKeyToValidate = Console.ReadLine();

        // TODO: Créer un objet ServerConfig avec serverName et port

        // TODO: Définir la clé API en utilisant la propriété en écriture seule

        // TODO: Valider la clé API et afficher les résultats
        // Format : Server: {ServerName}, Port: {Port}
        //         API Key Valid: {True/False}
    }
}