virtueel (C#-verwijzing)

  • Artikel

Het virtual trefwoord wordt gebruikt om een methode, eigenschap, indexeerfunctie of gebeurtenisdeclaratie te wijzigen en toe te staan dat het wordt overschreven in een afgeleide klasse. Deze methode kan bijvoorbeeld worden overschreven door elke klasse die deze overschrijft:

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

De implementatie van een virtueel lid kan worden gewijzigd door een overschrijvend lid in een afgeleide klasse. Zie Versiebeheer met de onderdrukking en nieuwe trefwoorden en weten wanneer u onderdrukking en nieuwe trefwoorden gebruikt voor meer informatie over het gebruik van het virtual trefwoord.

Opmerkingen

Wanneer een virtuele methode wordt aangeroepen, wordt het runtimetype van het object gecontroleerd op een overschrijvend lid. Het overschrijvende lid in de meest afgeleide klasse wordt aangeroepen, wat het oorspronkelijke lid kan zijn, als er geen afgeleide klasse het lid heeft overschreven.

Standaard zijn methoden niet-virtueel. U kunt een niet-virtuele methode niet overschrijven.

U kunt de virtual wijzigingsfunctie niet gebruiken met de static, abstractof overrideprivatemodifiers. In het volgende voorbeeld ziet u een virtuele eigenschap:

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 (!string.IsNullOrEmpty(value))
            {
                _name = value;
            }
            else
            {
                _name = "Unknown";
            }
        }
    }
}

Virtuele eigenschappen gedragen zich als virtuele methoden, met uitzondering van de verschillen in declaratie- en aanroepsyntaxis.

  • Het is een fout bij het gebruik van de virtual wijzigingsfunctie voor een statische eigenschap.

  • Een virtuele overgenomen eigenschap kan worden overschreven in een afgeleide klasse door een eigenschapsdeclaratie op te nemen die gebruikmaakt van de override wijzigingsfunctie.

Opmerking

In dit voorbeeld bevat de Shape klasse de twee coördinaten xen yde Area() virtuele methode. Verschillende shapeklassen, zoals Circle, Cylinderen Sphere nemen de Shape klasse over en het oppervlak wordt voor elke afbeelding berekend. Elke afgeleide klasse heeft een eigen onderdrukkings-implementatie van Area().

U ziet dat de overgenomen klassen Circleen CylinderSphere alle constructors gebruiken die de basisklasse initialiseren, zoals wordt weergegeven in de volgende declaratie.

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

In het volgende programma wordt het juiste gebied voor elke afbeelding berekend en weergegeven door de juiste implementatie van de Area() methode aan te roepen, afhankelijk van het object dat is gekoppeld aan de methode.

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

C#-taalspecificatie

Zie de C#-taalspecificatie voor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.

Zie ook