Le langage C# est conçu de telle sorte que le versioning entre les classes de base et les classes dérivées dans différentes bibliothèques puisse évoluer et préserver une compatibilité descendante. Cela signifie, par exemple, que l'introduction dans une classe de base d'un nouveau membre portant le même nom qu'un membre dans une classe dérivée est totalement prise en charge par C# et n'engendre pas de comportement imprévisible. Cela signifie également qu'une classe doit indiquer de façon explicite si une méthode est conçue pour substituer une méthode héritée ou s'il s'agit d'une nouvelle méthode qui masque simplement une méthode héritée portant un nom similaire.

C# permet aux classes dérivées de contenir des méthodes portant le même nom que des méthodes de classe de base.

• La méthode de classe de base doit être définie comme virtuelle.

• Si la méthode dans la classe dérivée n'est pas précédée des mots clés new ou override, le compilateur émet un avertissement et la méthode se comporte comme si le mot clé new était présent.

• Si la méthode dans la classe dérivée est précédée du mot clé new, la méthode est définie comme étant indépendante de la méthode dans la classe de base.

• Si la méthode dans la classe dérivée est précédée du mot clé override, les objets de la classe dérivée appelleront cette méthode plutôt que la méthode de la classe de base.

• La méthode de la classe de base peut être appelée à partir de la classe dérivée à l'aide du mot clé base.

• Les mots clés override, virtual et new peuvent également être appliqués aux propriétés, indexeurs et événements.

Par défaut, les méthodes C# ne sont pas virtuelles - si une méthode est déclarée comme virtuelle, toute classe qui hérite de la méthode peut en implémenter sa propre version. Pour créer une méthode virtuelle, le modificateur virtual est utilisé dans la déclaration de méthode de la classe de base. La classe dérivée peut ensuite substituer la méthode virtuelle de base avec le mot clé override ou masquer la méthode virtuelle dans la classe de base avec le mot clé new. Si ni le mot clé override ni le mot clé new ne sont spécifiés, le compilateur émettra un avertissement et la méthode dans la classe dérivée masquera la méthode dans la classe de base. Pour plus d'informations, consultez Avertissement du compilateur CS0108.

Pour démontrer ceci en pratique, supposez par exemple que la société A a créé une classe intitulée GraphicsClass, que votre programme utilise. GraphicsClass ressemble à ceci :

class GraphicsClass
{
    public virtual void DrawLine() { }
    public virtual void DrawPoint() { }
}

Votre société utilise cette classe, et vous l'utilisez pour dériver votre propre classe, en ajoutant une nouvelle méthode :

class YourDerivedGraphicsClass : GraphicsClass
{
    public void DrawRectangle() { }
}

Votre application est utilisée sans problème, jusqu'à ce que la société A sorte une nouvelle version de GraphicsClass, qui ressemble à ceci :

class GraphicsClass
{
    public virtual void DrawLine() { }
    public virtual void DrawPoint() { }
    public virtual void DrawRectangle() { }
}

La nouvelle version de GraphicsClass contient désormais une méthode intitulée DrawRectangle. Au début, rien ne se produit. La nouvelle version est encore binairement compatible avec l'ancienne - tous les logiciels que vous avez déployés continueront à fonctionner, même si la nouvelle classe est installée sur ces systèmes informatiques. Tout appel existant à la méthode DrawRectangle continuera à faire référence à votre version, dans votre classe dérivée.

Toutefois, une fois que vous aurez recompilé votre application à l'aide de la nouvelle version de GraphicsClass, vous recevrez un avertissement du compilateur. Pour plus d'informations, consultez Avertissement du compilateur CS0108.

Cet avertissement vous informe que vous devez envisager comment vous souhaitez que votre méthode DrawRectangle se comporte dans votre application.

Si vous souhaitez que votre méthode substitue la nouvelle méthode de la classe de base, utilisez le mot clé override, comme ceci :

class YourDerivedGraphicsClass : GraphicsClass
{
    public override void DrawRectangle() { }
}

Le mot clé override garantit que tous les objets dérivés de YourDerivedGraphicsClass utiliseront la version de classe dérivée de DrawRectangle. Les objets dérivés de YourDerivedGraphicsClass peuvent accéder encore à la version de la classe de base de DrawRectangle à l'aide du mot clé base, comme ceci :

base.DrawRectangle();

Si vous ne souhaitez pas que votre méthode substitue la nouvelle méthode de classe de base, tenez compte des considérations suivantes. Pour éviter toute confusion entre les deux méthodes, vous pouvez renommer votre méthode. Cela peut prendre du temps, engendrer des erreurs et simplement pas pratique dans certaines situations. Toutefois, si votre projet est relativement petit, vous pouvez utiliser les options de refactorisation de Visual Studio pour renommer la méthode. Pour plus d'informations, consultez Types et classes de refactorisation.

Par ailleurs, vous pouvez empêcher l'avertissement à l'aide du mot clé new dans votre définition de classe dérivée, comme ceci :

class YourDerivedGraphicsClass : GraphicsClass
{
    public new void DrawRectangle() { }
}

L'utilisation du mot clé new indique au compilateur que votre définition masque la définition contenue dans la classe de base. Il s'agit du comportement par défaut.

Substitution et sélection de méthode

public class Derived : Base
{
    public override void DoWork(int param) { }
    public void DoWork(double param) { }
}

int val = 5;
Derived d = new Derived();
d.DoWork(val);  // Calls DoWork(double).

((Base)d).DoWork(val);  // Calls DoWork(int) on Derived.

Voir aussi