Mot-clé virtuel en C#

Quel est le mot clé virtuel ? Avant de passer directement à la perspective C#, il est important de comprendre ou de réviser le concept d'héritage, de remplacement et de mot-clé virtuel dans le monde de la programmation orientée objet.

Method Overriding est un concept de POO étroitement lié à l'héritage. Lorsqu'une méthode de classe enfant remplace la méthode de classe parent du même nom, des mêmes paramètres et du même type de retour, elle est appelée remplacement de méthode. Un mot-clé virtuel indique au compilateur qu'une méthode peut être remplacée dans les classes dérivées.

En ce qui concerne la perspective C#, le mot-clé virtual est utilisé pour modifier la déclaration de toute propriété, méthode ou événement afin de permettre la substitution dans une classe dérivée. En termes simples, le mot-clé virtual implémente le concept de substitution de méthode en C#.

Syntaxe

Toute propriété, méthode ou événement peut être remplacé en ajoutant le mot-clé virtuel dans la classe de base et en remplaçant le mot-clé dans la classe dérivée.

Ajoutez le mot-clé virtuel dans la déclaration de la classe de base :

public class Base {
public virtual int abc { get; set; } // this property can be overridden
public virtual void Xyz() { }         // this method can be overridden
}

Ajoutez le mot-clé override dans la déclaration de la classe de base :

public class Derived : Base {
public override int abc { get; set; } // this overrides the base class property
public override void Xyz() { }        // this overrides the base class method
}

Comment fonctionne Virtual en C# ?

La différence fondamentale entre la surcharge et la substitution est que la première est un mécanisme de compilation, tandis que la seconde entre en jeu au moment de l'exécution. Un mot-clé virtuel entre en action au moment de l'exécution, implémentant ainsi le concept de substitution de méthode.

Lorsqu'une méthode ou une propriété virtuelle est invoquée ou accessible, le compilateur recherche un membre prioritaire de la méthode ou de la propriété. Si on en trouve un, il est invoqué. Si aucune n'est trouvée, la méthode ou la propriété d'origine est invoquée.

Une excellente question se pose ici : que se passe-t-il dans le cas d’un héritage à plusieurs niveaux ? Eh bien, si un membre de la classe est remplacé à plusieurs niveaux, le membre le plus profondément remplacé est invoqué (celui de la classe la plus dérivée).

Exemple

L'exemple suivant de mot-clé virtuel en C#  est mentionné ci-dessous

Héritage à un seul niveau

Prenons un exemple pour comprendre le fonctionnement d'un mot-clé virtuel lorsqu'une seule classe enfant hérite de la classe parent, c'est-à-dire qu'il n'y a pas d'héritage à plusieurs niveaux.

Code :

using System;
public class Polynomial
{
public virtual double len
{
get;
set;
}
public virtual double wid
{
get;
set;
}
public virtual double Area()
{
return len * wid;
}
}
public class Rectangle: Polynomial
{
}
public class Square : Polynomial
{
public override double len
{
get;
set;
}
public override double Area()
{
return len * len;
}
}
public class Circle : Polynomial
{
public double radius
{
get;
set;
}
public override double Area()
{
return Math.PI * radius * radius;
}
}
public class Triangle : Polynomial
{
public override double Area()
{
return 0.5 * len * wid;
}
}
public class Program
{
public static void Main()
{
var rect = new Rectangle();
rect.len = 5;
rect.wid = 10;
Console.WriteLine("Area of Rectangle = " + rect.Area());
var sq = new Square();
sq.len = 15;
Console.WriteLine("Area of Square = " + sq.Area());
var cir = new Circle();
cir.radius = 10;
Console.WriteLine("Area of Circle = " + cir.Area());
var tri = new Triangle();
tri.len = 5;
tri.wid = 10;
Console.WriteLine("Area of Triangle = " + tri.Area());
}
}

Sortie :

Comment fonctionne le code ci-dessus ?

Dans la classe de base Polynomial, nous avons déclaré deux propriétés et une méthode comme virtuelles. Ceux-ci peuvent désormais être remplacés dans les classes enfants. Nous créons maintenant diverses classes enfants de formes différentes héritant de la classe Polynomial.

Dans la classe Rectangle, nous n'avons besoin de remplacer aucune propriété ou méthode. L'implémentation de la classe de base fonctionnerait telle quelle pour la classe Rectangle.

Dans la classe Square, nous n'avons pas la propriété width. Nous remplaçons donc la propriété length et la méthode Area pour renvoyer le carré de la longueur.

Dans la classe Cercle, nous n'avons ni longueur ni largeur. Nous déclarons donc une nouvelle propriété de rayon spécifique à la classe et remplaçons la méthode Area en conséquence.

Dans la classe Triangle, nous remplaçons simplement la méthode Area et les propriétés sont héritées de la classe de base Polynomial.

Lorsque nous créons des objets des classes dérivées, le compilateur rencontre le mot-clé virtuel lors de la construction de la classe de base et recherche ainsi les membres remplacés. Les membres remplacés sont ensuite invoqués en conséquence.

Héritage à plusieurs niveaux

Modifions l'exemple ci-dessus pour inclure l'héritage multiniveau.

Code :

using System;
public class Polynomial
{
public virtual double len {       get; set; }
public virtual double wid {       get; set; }
public virtual double Area()
{ return 0; }
}
public class Rectangle : Polynomial
{
public override double Area()
{ return len * wid; }
}
public class Square : Rectangle
{
public override double len { get; set; }
public override double Area()
{ return len * len; }
}
public class Program
{
public static void Main()
{
var rect = new Rectangle();
rect.len = 5;
rect.wid = 10;
Console.WriteLine("Area of Rectangle = " + rect.Area());
var sq = new Square();
sq.len = 15;
Console.WriteLine("Area of Square = " + sq.Area());
}
}

Sortie :

Avantages

Un membre virtuel a des déclarations et des définitions à la fois dans la classe de base et dans les classes dérivées. Les membres virtuels sont avantageux lorsque certaines fonctionnalités supplémentaires sont requises dans les classes dérivées. Ils servent de modules complémentaires.

Règles

• Une variable ne peut pas être déclarée virtuelle. Seules les propriétés, méthodes et événements peuvent être déclarés comme virtuels.
• Un membre statique ne peut pas être déclaré virtuel.
• Un membre abstrait ne peut pas être déclaré virtuel.
• Un membre privé ne peut pas être déclaré virtuel.
• Un membre non virtuel ne peut pas être remplacé.
• Le niveau d'accès, le type et le nom des membres virtuels et des membres suppléants doivent être les mêmes. Par exemple, si la méthode virtuelle est publique, la méthode de remplacement doit également être publique.

Conclusion

Dans cet article, nous avons compris le concept de virtuel en C#. Nous avons vu comment C# implémente le mot-clé virtuel pendant l'exécution et examiné les exemples.

Les membres virtuels sont un excellent concept de programmation orientée objet. Cependant, pour acquérir des connaissances approfondies, il est fortement recommandé de se renseigner sur les mots-clés abstraits, les interfaces et les nouveaux mots-clés. Cela aiderait grandement à comprendre la différence entre eux tous. Cela aide à comprendre quand utiliser et quand ne pas utiliser le virtuel.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!