Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

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#).

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.

Dans cet exemple, la classe Shape 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 Shape, et la surface est calculée pour chaque figure. Chaque classe dérivée possède sa propre implémentation de substitution de Area().

Notez que les classes héritées Circle, Sphere, et Cylinder tous les constructeurs d'utilisation 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 illustration en appelant l'implémentation appropriée de la méthode d' 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)
        {
            this.x = x;
            this.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;
        }
    }

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

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

    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   = {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
    */


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.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft