Récapitulatif - Hiérarchie des employés

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

Défi

Facile

Construisons un système de hiérarchie des employés qui rassemble tous les concepts d’héritage de ce chapitre. Vous allez créer une structure d’entreprise dans laquelle différents types d’employés partagent des attributs communs, mais calculent leurs primes différemment.

Vous organiserez votre code sur quatre fichiers :

Employee.cs : définissez la classe de base Employee dans l’espace de noms Company. Chaque employé possède un Name (string) et un Salary (decimal). Créez un constructeur qui accepte ces deux valeurs. Ajoutez une méthode virtual appelée CalculateBonus() qui renvoie par défaut 10 % du salaire. Redéfinissez ToString() pour qu’elle renvoie "{Name} - ${Salary}".
Manager.cs : définissez une classe Manager dans l’espace de noms Company qui hérite de Employee. Les responsables possèdent une propriété supplémentaire TeamSize (int). Le constructeur doit accepter le nom, le salaire et la taille de l’équipe, en utilisant base pour initialiser la classe parente. Redéfinissez CalculateBonus() pour qu’elle renvoie 15 % du salaire plus 50 $ pour chaque membre de l’équipe. Redéfinissez ToString() pour qu’elle renvoie "{Name} - ${Salary} (Manager, Team: {TeamSize})".
Developer.cs : définissez une classe Developer dans l’espace de noms Company qui hérite de Employee. Les développeurs possèdent une propriété ProgrammingLanguage (string). Le constructeur accepte le nom, le salaire et le langage de programmation. Redéfinissez CalculateBonus() pour qu’elle renvoie 12 % du salaire. Redéfinissez ToString() pour qu’elle renvoie "{Name} - ${Salary} (Developer, {ProgrammingLanguage})".
Program.cs : dans votre fichier principal, créez un employé de chaque type à partir de valeurs saisies. Stockez les trois employés dans un tableau de références Employee afin de démontrer le polymorphisme. Parcourez le tableau et affichez le résultat de ToString() de chaque employé, suivi de sa prime.

Vous recevrez six entrées :

Nom de l’employé de base
Salaire de l’employé de base
Nom du responsable
Salaire du responsable
Taille de l’équipe du responsable
Nom du développeur
Salaire du développeur
Langage de programmation du développeur

Affichez les informations et la prime de chaque employé au format suivant :

{ToString result}
Bonus: ${CalculateBonus result}

Par exemple, si les entrées sont John, 50000, Sarah, 80000, 5, Mike, 70000 et C#, la sortie doit être :

John - $50000
Bonus: $5000
Sarah - $80000 (Manager, Team: 5)
Bonus: $12250
Mike - $70000 (Developer, C#)
Bonus: $8400

Remarquez que chaque type d’employé calcule les primes différemment, mais que vous pouvez tous les traiter au moyen d’un seul tableau Employee. C’est toute la puissance de la combinaison de l’héritage et du polymorphisme !

Essayez vous-même

using System;
using Company;

class Program
{
    public static void Main(string[] args)
    {
        // Lire les entrées de base de l'employé
        string empName = Console.ReadLine();
        decimal empSalary = Convert.ToDecimal(Console.ReadLine());
        
        // Lire les entrées du manager
        string mgrName = Console.ReadLine();
        decimal mgrSalary = Convert.ToDecimal(Console.ReadLine());
        int teamSize = Convert.ToInt32(Console.ReadLine());
        
        // Lire les entrées du développeur
        string devName = Console.ReadLine();
        decimal devSalary = Convert.ToDecimal(Console.ReadLine());
        string progLang = Console.ReadLine();
        
        // TODO: Créer un Employee, un Manager et un Developer
        
        // TODO: Stocker les trois dans un tableau de type Employee pour démontrer le polymorphisme
        
        // TODO: Parcourir le tableau et afficher le `ToString()` et le bonus de chaque employé
        // Format :
        // {résultat de ToString}
        // Bonus: ${résultat de CalculateBonus}
    }
}