Partager via

Versioning avec les mots clés override et new (Guide de programmation C#)

Le langage C# est conçu pour que le contrôle de version entre les classes de base et dérivées dans différentes bibliothèques puisse évoluer et maintenir la compatibilité descendante. Cela signifie, par exemple, que l’introduction d’un nouveau membre dans une classe de base portant le même nom qu’un membre d’une classe dérivée est entièrement prise en charge par C# et n’entraîne pas de comportement inattendu. Cela signifie également qu’une classe doit indiquer explicitement si une méthode est destinée à remplacer une méthode héritée, ou si une méthode est une nouvelle méthode qui masque une méthode héritée de même nom.

En C#, les classes dérivées peuvent contenir des méthodes portant le même nom que les méthodes de classe de base.

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

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

  • Si la méthode de la classe dérivée est précédée du override mot clé, les objets de la classe dérivée appellent cette méthode au lieu de la méthode de classe de base.

  • Pour appliquer le override mot clé à la méthode dans la classe dérivée, la méthode de classe de base doit être définie virtuelle.

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

  • Les mots clés override, virtual et new peuvent également être appliqués aux propriétés, aux indexeurs et aux é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 implémenter sa propre version. Pour rendre une méthode virtuelle, le virtual modificateur est utilisé dans la déclaration de méthode de la classe de base. La classe dérivée peut ensuite remplacer la méthode virtuelle de base à l’aide du override mot clé ou masquer la méthode virtuelle dans la classe de base à l’aide du new mot clé. Si ni le override mot clé ni new le mot clé n’est spécifié, le compilateur émet un avertissement et la méthode de la classe dérivée masque la méthode dans la classe de base.

Pour illustrer cela dans la pratique, supposons pour un moment que la société A a créé une classe nommée GraphicsClass, que votre programme utilise. Les éléments suivants représentent GraphicsClass :

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

Votre entreprise 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 publie une nouvelle version de GraphicsClass, qui ressemble au code suivant :

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

La nouvelle version de GraphicsClass maintenant contient une méthode nommée DrawRectangle. Au départ, rien ne se produit. La nouvelle version est toujours compatible binaire avec l’ancienne version. Tous les logiciels que vous avez déployés continueront de fonctionner, même si la nouvelle classe est installée sur ces systèmes informatiques. Tous les appels existants à la méthode DrawRectangle continueront de référencer votre version dans votre classe dérivée.

Toutefois, dès que vous recompilez votre application à l’aide de la nouvelle version de GraphicsClass, vous recevrez un avertissement du compilateur CS0108. Cet avertissement vous informe que vous devez prendre en compte la façon dont vous souhaitez que votre DrawRectangle méthode se comporte dans votre application.

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

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

Le override mot clé garantit que tous les objets dérivés YourDerivedGraphicsClass utilisent la version de classe dérivée de DrawRectangle. Les objets dérivés de YourDerivedGraphicsClass peuvent toujours accéder à la version de la classe de base de DrawRectangle en utilisant le mot clé 'base':

base.DrawRectangle();

Si vous ne souhaitez pas que votre méthode remplace la nouvelle méthode de classe de base, les considérations suivantes s’appliquent. Pour éviter toute confusion entre les deux méthodes, vous pouvez renommer votre méthode. Cela peut être fastidieux et sujette à des erreurs, et ce n’est pas pratique dans certains cas. 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 Refactorisation des classes et des types (Concepteur de classes).

Vous pouvez également empêcher l’avertissement à l’aide du mot clé new dans votre définition de classe dérivée :

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

L’utilisation du new mot clé 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

Lorsqu’une méthode est nommée sur une classe, le compilateur C# sélectionne la meilleure méthode à appeler si plusieurs méthodes sont compatibles avec l’appel, par exemple lorsqu’il existe deux méthodes portant le même nom et les paramètres compatibles avec le paramètre passé. Les méthodes suivantes sont compatibles :

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

Lorsqu'un appel est effectué sur une instance de DoWork, le compilateur C# essaie d'abord de rendre l'appel compatible avec les versions de Derived qui avaient été déclarées à l'origine dans DoWork. Les méthodes de remplacement ne sont pas considérées comme déclarées sur une classe, elles sont de nouvelles implémentations d’une méthode déclarée sur une classe de base. Uniquement si le compilateur C# ne peut pas correspondre à l’appel de méthode à une méthode d’origine sur Derived, il tente de faire correspondre l’appel à une méthode substituée portant le même nom et les mêmes paramètres compatibles. Par exemple:

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

Étant donné que la variable val peut être convertie en double implicitement, le compilateur C# appelle DoWork(double) au lieu de DoWork(int). Il existe deux façons d’éviter cela. Tout d’abord, évitez de déclarer de nouvelles méthodes portant le même nom que les méthodes virtuelles. Ensuite, vous pouvez demander au compilateur C# d’appeler la méthode virtuelle en lui faisant rechercher dans la liste des méthodes de la classe de base en convertissant l’instance de Derived en Base. Étant donné que la méthode est virtuelle, l’implémentation de DoWork(int) sur Derived sera appelée. Par exemple:

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

Pour plus d’exemples de new et de override, consultez Savoir quand utiliser les mots clés override et new.

Voir aussi