Classes Abstraites C# : Tutoriel Pratique avec Exemples de Code

Qu'est-ce qu'une Classe Abstraite en C# ?

Une classe abstraite sert de plan pour d'autres classes. Elle ne peut jamais être instanciée directement et est marquée avec le mot-clé abstract. Les classes abstraites contiennent généralement une ou plusieurs méthodes abstract ou virtual que les sous-classes sont censées implémenter ou redéfinir. Elles fournissent un contrat commun tout en permettant aux sous-classes concrètes de fournir un comportement spécifique.

Considérez l'exemple suivant. Nous définissons d'abord une classe générique Animal sans savoir si l'animal sera un chien, un chat ou autre chose. La méthode Description est un placeholder qui sera spécialisée par les classes dérivées.

Lorsque le type spécifique d'animal est connu, nous créons une sous-classe telle que Chien qui hérite de Animal. La classe Chien ne peut pas modifier la méthode de base Description ; au lieu de cela, elle fournit sa propre implémentation ou ajoute de nouvelles méthodes comme ChienDescription. Cela démontre le concept central des classes abstraites C# : un contrat de base avec des sous-classes concrètes comblant les détails.

Création d'une Classe Abstraite en C#

Voici un guide étape par étape pour définir une classe abstraite et une sous-classe concrète qui l'utilise. Bien que nous n'exécutions pas cet extrait dans un éditeur en ligne, le code démontre les meilleures pratiques pour la conception de classes abstraites.

Étape 1 : Définir la Classe Abstraite

Nous créons une classe abstraite nommée Tutoriel contenant une seule méthode virtual. Le mot-clé virtual indique que la méthode ne peut pas être redéfinie par les classes dérivées.

Explication du Code

1. Nous déclarons la classe avec le mot-clé abstract pour empêcher l'instanciation directe.
2. À l'intérieur de la classe, la méthode Set est définie comme public virtual void Set() afin que les sous-classes l'héritent inchangée.

Étape 2 : Créer la Classe Dérivée

Dans le même fichier, nous définissons une classe concrète Guru99Tutoriel qui hérite de Tutoriel. La sous-classe introduit ses propres propriétés et méthodes tout en respectant le contrat établi par la base abstraite.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DemoApplication {
    abstract class Tutoriel {
        public virtual void Set() {
            // Implémentation de base (actuellement vide)
        }
    }
    class Guru99Tutoriel : Tutoriel {
        protected int TutorialID;
        protected string TutorialName;
        public void SetTutorial(int pID, string pName) {
            TutorialID = pID;
            TutorialName = pName;
        }
        public string GetTutorial() {
            return TutorialName;
        }
        static void Main(string[] args) {
            Guru99Tutoriel pTutor = new Guru99Tutoriel();
            pTutor.SetTutorial(1, ".Net");
            Console.WriteLine(pTutor.GetTutorial());
            Console.ReadKey();
        }
    }
}

Le point clé est que Guru99Tutoriel ne peut pas redéclarer la méthode Set définie dans Tutoriel ; elle doit utiliser la version héritée telle quelle.

Résumé

Les classes abstraites en C# fournissent une base robuste pour construire des systèmes extensibles. En déclarant un comportement commun dans une classe de base non instanciable, les développeurs imposent un contrat tout en permettant aux classes dérivées de fournir des implémentations concrètes. Ce pattern favorise la réutilisation du code, la clarté et le typage fort dans de grandes bases de code.