C# new vs override

1. le new mot-clé en C#
2. le mot-clé override en C#

Ce tutoriel discutera de la différence entre les mots-clés new et override en C#.

le new mot-clé en C#

Le new mot-clé est très courant en C#. Traditionnellement, il peut être utilisé à trois endroits distincts : opérateur, modificateur et contrainte.

La première et la plus populaire utilisation du mot-clé new est en tant qu’opérateur pour créer des objets de classe et invoquer leurs constructeurs de classe en C#. Avec le mot-clé new, des objets de type valeur comme int et float sont créés à l’intérieur de la pile, et des objets de type référence comme des classes définies par l’utilisateur sont créés à l’intérieur du tas.

Certaines choses à garder à l’esprit lors de l’utilisation du mot-clé new en tant qu’opérateur sont les suivantes : il affecte uniquement la mémoire à l’objet et ne détruit aucune mémoire qui dépendait auparavant de la même portée, et nous ne pouvons pas remplacer la fonctionnalité du nouveau mot-clé en C#.

Deuxièmement, tout en utilisant le mot-clé new comme modificateur, il masque les membres de la classe de base hérités de la classe dérivée. L’instruction précédente signifie qu’au lieu de remplacer ou de déclarer une nouvelle définition de ce membre de classe hérité, le mot-clé new remplace la définition précédente de ce membre dans la classe de base.

La troisième utilisation du mot-clé new est relativement rare par rapport aux deux précédentes. En utilisant le mot-clé new comme contrainte, nous spécifions que le type générique doit avoir un constructeur public sans paramètres supplémentaires.

L’inconvénient de cette approche est que nous ne pouvons pas l’utiliser avec un type abstrait.

Pour les besoins de ce didacticiel, nous utiliserons le mot-clé new comme modificateur pour masquer la définition de la classe de base de la classe dérivée. En C#, le compilateur masque implicitement la définition de toutes les fonctions héritées par défaut.

L’extrait de code suivant montre comment masquer explicitement la définition d’une fonction héritée de la classe dérivée à l’aide du mot-clé new.

public class BaseClass {
  public virtual void fun() {
    Console.WriteLine("Base class");
  }
}

public class DerivedClass : BaseClass {
  public new void fun() { Console.WriteLine("Derived class");
}
public static void Main(string[] args) {
  BaseClass b = new BaseClass();
  DerivedClass d = new DerivedClass();
  BaseClass bd = new DerivedClass();
  b.fun();
  d.fun();
  bd.fun();
}
}

Production:

Base class
Derived class
Base class

La sortie pour les deux premiers objets est assez simple ; l’objet BaseClass b référence la fonction fun() à l’intérieur de la classe de base et l’objet DerivedClass d référence la fonction fun() à l’intérieur de la classe dérivée.

Une chose très intéressante se produit lorsque nous assignons la référence de la classe dérivée à un objet de la classe de base bd et invoquons la fonction fun(). La fonction fun() à l’intérieur de la classe de base est toujours exécutée cette fois.

En effet, l’implémentation de la fonction fun() dans la classe de base est masquée dans la classe dérivée.

Ce même objectif peut être atteint sans utiliser le mot-clé new. L’extrait de code suivant montre comment nous pouvons atteindre le même objectif sans utiliser le mot-clé new.

public class BaseClass {
  public virtual void fun() {
    Console.WriteLine("Base class");
  }
}

public class DerivedClass : BaseClass {
  public void fun() {
    Console.WriteLine("Derived class");
  }
  public static void Main(string[] args) {
    BaseClass b = new BaseClass();
    DerivedClass d = new DerivedClass();
    BaseClass bd = new DerivedClass();
    b.fun();
    d.fun();
    bd.fun();
  }
}

Production:

Base class
Derived class
Base class

Notez que la sortie est la même que l’approche précédente. La seule différence ici est que cette fois, nous recevons un avertissement du compilateur indiquant que pour masquer explicitement le membre de la classe, utilisez le mot-clé new.

le mot-clé override en C#

En C#, le modificateur override étend la méthode héritée de la classe de base. Le mot clé override fournit une nouvelle implémentation de la méthode virtual héritée de la classe de base.

Une chose à noter ici est que nous ne pouvons pas utiliser le mot-clé override pour étendre une méthode non virtuelle ou static. La fonction de la classe de base doit être virtuelle, abstraite ou remplacée par une autre super classe.

Dans le contexte de notre exemple précédent, l’extrait de code suivant montre comment nous pouvons utiliser le modificateur override pour étendre les fonctionnalités d’une fonction virtual héritée de la classe de base.

public class BaseClass {
  public virtual void fun() {
    Console.WriteLine("Base class");
  }
}

public class DerivedClass : BaseClass {
  public override void fun() {
    Console.WriteLine("Derived class");
  }
  public static void Main(string[] args) {
    BaseClass b = new BaseClass();
    DerivedClass d = new DerivedClass();
    BaseClass bd = new DerivedClass();
    b.fun();
    d.fun();
    bd.fun();
  }
}

Production:

Base class
Derived class
Derived class

La sortie pour les deux premiers objets est assez simple ; l’objet BaseClass b référence la fonction fun() à l’intérieur de la classe de base et l’objet DerivedClass d référence la fonction fun() à l’intérieur de la classe dérivée.

La vraie différence avec le mot-clé new apparaît lorsque nous attribuons la référence de la classe dérivée à un objet de la classe de base bd et invoquons la fonction fun(). Contrairement aux deux exemples précédents, cette fois, la fonction fun() de la classe dérivée est invoquée.

Le mot clé override est utilisé pour montrer l’implémentation enfant d’une fonction virtuelle à son objet parent, tandis que le nouveau mot clé est utilisé pour masquer l’implémentation enfant de son objet de classe parent.