Delen via

virtueel (C#-verwijzing)

Gebruik het virtual trefwoord om een methode, eigenschap, indexeerfunctie of gebeurtenisdeclaratie te wijzigen en een afgeleide klasse toe te staan deze te overschrijven.

De C#-taalreferentiedocumenten beschrijven de meest recent uitgebrachte versie van de C#-taal. Het bevat ook de eerste documentatie voor functies in openbare previews voor de aanstaande taalrelease.

De documentatie identificeert alle functies die voor het eerst zijn geïntroduceerd in de laatste drie versies van de taal of in de huidige openbare previews.

Aanbeveling

Raadpleeg het artikel over de versiegeschiedenis van de C#-taal om te achterhalen wanneer een functie voor het eerst is geïntroduceerd in C#.

Elke klasse die deze methode overschrijft, kan deze bijvoorbeeld overschrijven:

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

Een overschrijvend lid in een afgeleide klasse kan de implementatie van een virtueel lid wijzigen. Voor meer informatie over het gebruik van het virtual trefwoord, zie Versiebeheer met de trefwoorden Override en New en Wanneer te gebruiken: Override en New trefwoorden.

Wanneer u een virtuele methode aanroept, controleert de runtime het type van het object voor een overschrijvend lid. Hiermee wordt het overschrijvende lid in de meest afgeleide klasse aanroepen. Als er geen afgeleide klasse het lid overschrijft, wordt het oorspronkelijke lid aangeroepen.

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

In het volgende voorbeeld ziet u een virtuele eigenschap:

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";
            }
        }
    }
}

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

  • 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 x en y, en de 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 overschrijfimplementatie van Area().

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

C#-taalspecificatie

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

Zie ook

  • Last updated on