virtual (référence C#)
Le mot clé virtual sert à modifier une méthode, une propriété, un indexeur ou une déclaration de l'événement et leur permet d'être substitués dans une classe dérivée. Par exemple, cette méthode peut être substituée par toute classe qui en hérite :
public virtual double Area()
{
return x * y;
}
L'implémentation d'un membre virtual peut être modifiée par un membre de substitution dans une classe dérivée. Pour plus d'informations sur l'utilisation du mot clé virtual, consultez Versioning avec les mots clés override et new (Guide de programmation C#) et Savoir quand utiliser les mots clés override et new (Guide de programmation C#).
Notes
Lorsqu'une méthode virtuelle est appelée, un membre de substitution est recherché dans le type d'objet au moment de l'exécution. Le membre de substitution de la classe la plus dérivée est appelé (cela peut être le membre d'origine), si aucune classe dérivée n'a substitué le membre.
Par défaut, les méthodes ne sont pas virtual. Vous ne pouvez pas substituer une méthode non virtuelle.
Vous ne pouvez pas utiliser le modificateur virtual avec les modificateurs static, abstract, private ou override. L'exemple suivant affiche une propriété virtuelle :
class MyBaseClass
{
// virtual auto-implemented property. Overrides can only
// provide specialized behavior if they implement get and set accessors.
public virtual string Name { get; set; }
// ordinary virtual property with backing field
private int num;
public virtual int Number
{
get { return num; }
set { num = value; }
}
}
class MyDerivedClass : MyBaseClass
{
private string name;
// Override auto-implemented property with ordinary property
// to provide specialized accessor behavior.
public override string Name
{
get
{
return name;
}
set
{
if (value != String.Empty)
{
name = value;
}
else
{
name = "Unknown";
}
}
}
}
Les propriétés virtual se comportent comme les méthodes abstraites, à l'exception des différences dans la syntaxe de déclaration et d'appel.
L'utilisation du modificateur virtual sur une propriété statique est une erreur.
Une propriété virtual héritée peut être substituée dans une classe dérivée en incluant une déclaration de propriété qui utilise le modificateur override.
Exemple
Dans cet exemple, la classe Dimensions contient les deux coordonnées x et y, ainsi que la méthode virtuelle Area(). Différentes classes de formes, telles que Circle, Cylinder et Sphere, héritent de la classe Dimensions, et la surface est calculée pour chaque figure. Chaque classe dérivée possède sa propre implémentation de substitution de Area(). Le programme calcule et affiche la surface exacte de chaque figure en appelant l'implémentation appropriée de Area() en fonction de l'objet associé à la méthode.
Notez que les classes héritées Circle, Sphere et Cylinder utilisent toutes des constructeurs qui initialisent la classe de base. Exemple :
public Cylinder(double r, double h): base(r, h) {}
Ceci est similaire à la liste d'initialisation C++.
class TestClass
{
public class Dimensions
{
public const double PI = Math.PI;
protected double x, y;
public Dimensions()
{
}
public Dimensions(double x, double y)
{
this.x = x;
this.y = y;
}
public virtual double Area()
{
return x * y;
}
}
public class Circle : Dimensions
{
public Circle(double r) : base(r, 0)
{
}
public override double Area()
{
return PI * x * x;
}
}
class Sphere : Dimensions
{
public Sphere(double r) : base(r, 0)
{
}
public override double Area()
{
return 4 * PI * x * x;
}
}
class Cylinder : Dimensions
{
public Cylinder(double r, double h) : base(r, h)
{
}
public override double Area()
{
return 2 * PI * x * x + 2 * PI * x * y;
}
}
static void Main()
{
double r = 3.0, h = 5.0;
Dimensions c = new Circle(r);
Dimensions s = new Sphere(r);
Dimensions l = new Cylinder(r, h);
// Display results:
Console.WriteLine("Area of Circle = {0:F2}", c.Area());
Console.WriteLine("Area of Sphere = {0:F2}", s.Area());
Console.WriteLine("Area of Cylinder = {0:F2}", l.Area());
}
}
/*
Output:
Area of Circle = 28.27
Area of Sphere = 113.10
Area of Cylinder = 150.80
*/
Spécification du langage C#
Pour plus d'informations, consultez la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.
Voir aussi
Référence
Polymorphisme (Guide de programmation C#)