Héritage en C# : comment appeler le constructeur de la classe de base (guide complet)

Introduction : pourquoi le constructeur de la classe de base n'est pas une "simple théorie ennuyeuse" ?

Imaginez que vous construisez une maison. Vous avez des fondations (la classe de base) et la maison elle-même (la classe dérivée). Les fondations sont déjà posées, mais pour que la maison tienne solidement, il faut correctement la "relier" aux fondations. En C#, cette "liaison" est assurée par l'appel du constructeur de la classe de base via le mot-clé base.

C'est l'un de ces sujets qui génèrent des milliers de questions sur Stack Overflow. Pourquoi ? Parce que sans comprendre ce mécanisme, votre code soit ne compilera pas, soit fonctionnera de manière imprévisible. Dans cet article, nous allons décortiquer l'appel du constructeur de la classe de base en C# du simple au complexe : avec des exemples, des pièges et des scénarios réels.

Que allez-vous apprendre dans cet article ?

\n
• Comment fonctionne l'héritage des constructeurs en C#.
\n
• Quand et pourquoi appeler explicitement base().
\n
• Comment passer des paramètres au constructeur de la classe de base.
\n
• Les erreurs typiques et comment les éviter.
\n
• Techniques avancées : chaînes de constructeurs et surcharge.
\n

1. Les bases : qu'est-ce qu'un constructeur de classe de base ?

En C#, chaque classe peut avoir un ou plusieurs constructeurs. Lorsque vous créez une instance d'une classe dérivée, le constructeur de la classe de base est appelé en premier. Cela garantit que tous les champs et propriétés du "parent" sont initialisés avant que le "descendant" ne commence à fonctionner.

Si vous ne spécifiez pas explicitement quel constructeur de la classe de base appeler, le compilateur tentera d'appeler le constructeur par défaut (sans paramètres). S'il n'existe pas, vous obtiendrez une erreur de compilation.

Exemple 1 : appel implicite (tout simple)

public class Animal\n{\n    public string Name { get; set; }\n\n    public Animal()\n    {\n        Name = "Animal inconnu";\n        Console.WriteLine("Animal : constructeur sans paramètres");\n    }\n}\n\npublic class Dog : Animal\n{\n    public Dog()\n    {\n        Console.WriteLine("Dog : constructeur");\n    }\n}\n\n// Utilisation\nDog dog = new Dog();\n// Affichage :\n// Animal : constructeur sans paramètres\n// Dog : constructeur

Ici, Dog appelle implicitement Animal(). Tout fonctionne car Animal possède un constructeur par défaut.

2. Le problème : quand il n'y a pas de constructeur par défaut

Imaginez maintenant que la classe de base exige des paramètres obligatoires. Par exemple, un animal doit avoir un nom. Si vous supprimez le constructeur sans paramètres, le code ne compilera plus.

Exemple 2 : erreur de compilation

public class Animal\n{\n    public string Name { get; }\n\n    public Animal(string name) // seul constructeur\n    {\n        Name = name;\n    }\n}\n\npublic class Dog : Animal\n{\n    // Erreur CS7036 : "Animal" ne contient pas de constructeur prenant 0 arguments\n    public Dog() \n    {\n    }\n}

Le compilateur crie : "Hé, je ne sais pas comment initialiser Animal sans nom !". La solution est d'appeler explicitement le constructeur de la classe de base avec base.

3. Le mot-clé base : appel explicite du constructeur

Le mot-clé base en C# est utilisé pour accéder aux membres de la classe de base. Dans le contexte des constructeurs, il permet de spécifier quel constructeur du parent doit être appelé et avec quels arguments.

Syntaxe :

public class ClasseDérivée : ClasseDeBase\n{\n    public ClasseDérivée(paramètres) : base(arguments)\n    {\n        // corps du constructeur\n    }\n}

Les deux-points et base(arguments) sont placés immédiatement après la signature du constructeur, avant le corps.

Exemple 3 : corrigeons l'erreur

public class Animal\n{\n    public string Name { get; }\n\n    public Animal(string name)\n    {\n        Name = name;\n        Console.WriteLine($"Animal : créé {name}");\n