Données d'instance vs statiques

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

Maintenant que vous comprenez les membres statiques, clarifions quand utiliser des données d'instance par rapport aux données statiques. Cette décision façonne la manière dont votre classe stocke et partage les informations.

Les données d'instance appartiennent à chaque objet individuellement. Chaque objet possède sa propre copie, et les modifications apportées à un objet n'affectent pas les autres :

public class BankAccount
{
    public string Owner { get; set; }      // Instance - unique par compte
    public decimal Balance { get; set; }   // Instance - unique par compte
}

Chaque BankAccount a son propre propriétaire et son propre solde. C'est logique car différents comptes détiennent des montants différents pour différentes personnes.

Les données statiques appartiennent à la classe elle-même et sont partagées entre toutes les instances :

public class BankAccount
{
    public static decimal InterestRate = 0.05m;  // Statique - identique pour tous
    public static int TotalAccounts = 0;         // Statique - suit tous les comptes
    
    public string Owner { get; set; }
    public decimal Balance { get; set; }
}

Le taux d'intérêt s'applique de la même manière à chaque compte, il est donc logique qu'il soit static. Le compteur total de comptes suit les informations à l'échelle de la classe, et non les données d'un compte individuel.

Une règle simple : si la donnée décrit un objet spécifique, rendez-la instance. Si elle décrit la class dans son ensemble ou doit être partagée, rendez-la static. Les mélanger de manière incorrecte entraîne des bogues où les données changent de manière inattendue entre les objets ou ne sont pas accessibles quand on en a besoin.

Défi

Facile

Construisons un suivi de session de jeu qui démontre la différence entre les données appartenant aux joueurs individuels et les données partagées sur l'ensemble du jeu.

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

Player.cs : Définissez une classe Player dans l'espace de noms GameSession. Chaque joueur possède son propre Username (string) et Score (int) - ceux-ci sont uniques à chaque joueur. La classe doit également suivre les informations qui s'appliquent à tous les joueurs : un champ statique GameName (string) qui stocke le nom du jeu auquel tout le monde joue, et un champ statique TotalPlayers (int) qui compte le nombre de joueurs ayant rejoint la partie. Incluez un constructeur qui prend le nom d'utilisateur et le score de départ, et qui incrémente automatiquement le nombre total de joueurs. Ajoutez une méthode statique SetGameName(string name) pour configurer le nom du jeu.
Program.cs : Dans votre fichier principal, configurez le jeu et créez des joueurs en fonction des entrées. Définissez d'abord le nom du jeu, puis créez deux joueurs et affichez leurs informations individuelles ainsi que les données de jeu partagées.

Vous recevrez cinq entrées :

Le nom du jeu
Le nom d'utilisateur du premier joueur
Le score de départ du premier joueur
Le nom d'utilisateur du deuxième joueur
Le score de départ du deuxième joueur

Affichez la sortie dans ce format :

Game: {GameName}
Player: {Username}, Score: {Score}
Player: {Username}, Score: {Score}
Total Players: {TotalPlayers}

Par exemple, si les entrées sont BattleArena, DragonSlayer, 1500, ShadowNinja, et 2200, la sortie devrait être :

Game: BattleArena
Player: DragonSlayer, Score: 1500
Player: ShadowNinja, Score: 2200
Total Players: 2

Réfléchissez bien aux données qui doivent être basées sur l'instance (différentes pour chaque joueur) et à celles qui doivent être statiques (partagées par tous les joueurs). Le nom du jeu et le nombre total de joueurs décrivent la session dans son ensemble, tandis que le nom d'utilisateur et le score sont uniques à chaque individu.

Aide-mémoire

Utilisez des données d'instance pour les propriétés qui sont uniques à chaque objet :

public class BankAccount
{
    public string Owner { get; set; }      // Chaque compte a son propre propriétaire
    public decimal Balance { get; set; }   // Chaque compte a son propre solde
}

Utilisez des données statiques pour les propriétés partagées par toutes les instances d'une classe :

public class BankAccount
{
    public static decimal InterestRate = 0.05m;  // Identique pour tous les comptes
    public static int TotalAccounts = 0;         // Suit tous les comptes
    
    public string Owner { get; set; }
    public decimal Balance { get; set; }
}

Règle de décision : Si les données décrivent un objet spécifique, utilisez des données d'instance. Si elles décrivent la classe dans son ensemble ou doivent être partagées, utilisez des données statiques.

Essayez vous-même

using System;

namespace GameSession
{
    class Program
    {
        public static void Main(string[] args)
        {
            // Lire les entrées
            string gameName = Console.ReadLine();
            string username1 = Console.ReadLine();
            int score1 = Convert.ToInt32(Console.ReadLine());
            string username2 = Console.ReadLine();
            int score2 = Convert.ToInt32(Console.ReadLine());

            // TODO: Définir le nom du jeu en utilisant la méthode statique

            // TODO: Créer deux objets Player avec les données d'entrée

            // TODO: Afficher la sortie au format requis
            // Game: {GameName}
            // Player: {Username}, Score: {Score}
            // Player: {Username}, Score: {Score}
            // Total Players: {TotalPlayers}
        }
    }
}