Partager via

virtual (référence C#)

Utilisez le virtual mot clé pour modifier une méthode, une propriété, un indexeur ou une déclaration d’événement et autoriser une classe dérivée à la remplacer.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

Par exemple, toute classe qui hérite de cette méthode peut la remplacer :

public virtual double Area()
{
    return x * y;
}

Un membre substitué dans une classe dérivée peut modifier l’implémentation d’un membre virtuel. Pour plus d’informations sur l’utilisation du mot clé virtual, consultez Gestion de version avec les mots clés override et new et Savoir quand utiliser les mots clés override et new.

Lorsque vous appelez une méthode virtuelle, le runtime vérifie le type de l’objet pour un membre substitué. Il appelle le membre substitué dans la classe la plus dérivée. Si aucune classe dérivée ne remplace le membre, le membre d’origine est appelé.

Par défaut, les méthodes ne sont pas virtuelles. Vous ne pouvez pas remplacer une méthode non virtuelle.

L’exemple suivant illustre une propriété virtuelle :

class MyBaseClass
{
    // virtual automatically 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 automatically implemented property with ordinary property
    // to provide specialized accessor behavior.
    public override string Name
    {
        get
        {
            return _name;
        }
        set
        {
            if (!string.IsNullOrEmpty(value))
            {
                _name = value;
            }
            else
            {
                _name = "Unknown";
            }
        }
    }
}

Les propriétés virtuelles se comportent comme les méthodes virtuelles, à l’exception des différences dans la syntaxe de déclaration et d’appel.

  • Une propriété virtuelle 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 Shape classe contient les deux coordonnées x et yla Area() méthode virtuelle. Différentes classes de formes, telles que Circle, Cylinder et Sphere, héritent de la classe Shape, et la surface est calculée pour chaque figure. Chaque classe dérivée a sa propre implémentation de substitution de Area().

Les classes Circlehéritées, Cylinderet Sphere tous les constructeurs qui initialisent la classe de base, comme indiqué dans la déclaration suivante.

public Cylinder(double r, double h): base(r, h) {}

Le programme suivant calcule et affiche la zone appropriée pour chaque figure en appelant l’implémentation appropriée de la méthode Area(), selon l’objet associé à la méthode.

class TestClass
{
    public class Shape
    {
        public const double PI = Math.PI;
        protected double _x, _y;

        public Shape()
        {
        }

        public Shape(double x, double y)
        {
            _x = x;
            _y = y;
        }

        public virtual double Area()
        {
            return _x * _y;
        }
    }

    public class Circle : Shape
    {
        public Circle(double r) : base(r, 0)
        {
        }

        public override double Area()
        {
            return PI * _x * _x;
        }
    }

    public class Sphere : Shape
    {
        public Sphere(double r) : base(r, 0)
        {
        }

        public override double Area()
        {
            return 4 * PI * _x * _x;
        }
    }

    public class Cylinder : Shape
    {
        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;
        Shape c = new Circle(r);
        Shape s = new Sphere(r);
        Shape l = new Cylinder(r, h);
        // Display results.
        Console.WriteLine($"Area of Circle   = {c.Area():F2}");
        Console.WriteLine($"Area of Sphere   = {s.Area():F2}");
        Console.WriteLine($"Area of Cylinder = {l.Area():F2}");
    }
}
/*
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, voir 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

  • Last updated on