Dela via

virtual (C#-referens)

Använd nyckelordet virtual för att ändra en metod, egenskap, indexerare eller händelsedeklaration och tillåta att en härledd klass åsidosätter den.

C#-språkreferensen dokumenterar den senaste versionen av C#-språket. Den innehåller även inledande dokumentation för funktioner i offentliga förhandsversioner för den kommande språkversionen.

Dokumentationen identifierar alla funktioner som först introducerades i de tre senaste versionerna av språket eller i aktuella offentliga förhandsversioner.

Tips/Råd

Information om när en funktion först introducerades i C# finns i artikeln om språkversionshistoriken för C#.

Till exempel kan alla klasser som ärver den här metoden åsidosätta den:

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

En övergripande medlem i en härledd klass kan ändra implementeringen av en virtuell medlem. Mer information om hur du använder nyckelordet virtual finns i Versionshantering med åsidosättning och nya nyckelord och Veta när du ska använda åsidosättning och nya nyckelord.

När du anropar en virtuell metod kontrollerar körningen typen av objekt för en övergripande medlem. Den anropar den överordnade medlemmen i den mest härledda klassen. Om ingen härledd klass åsidosätter medlemmen anropas den ursprungliga medlemmen.

Som standard är metoderna icke-virtuella. Du kan inte åsidosätta en icke-virtuell metod.

I följande exempel visas en virtuell egenskap:

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

Virtuella egenskaper fungerar som virtuella metoder, förutom skillnaderna i deklarations- och anropssyntax.

  • En virtuell ärvd egenskap kan åsidosättas i en härledd klass genom att inkludera en egenskapsdeklaration som använder override modifieraren.

Exempel

I det här exemplet Shape innehåller klassen de två koordinaterna x och y, och den Area() virtuella metoden. Olika formklasser, till exempel Circle, Cylinderoch Sphere ärver Shape klassen, och ytan beräknas för varje figur. Varje härledd klass har en egen åsidosättningsimplementering av Area().

De ärvda klasserna Circle, Cylinderoch Sphere alla använder konstruktorer som initierar basklassen enligt följande deklaration.

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

Följande program beräknar och visar lämpligt område för varje bild genom att anropa lämplig implementering av Area() metoden, enligt det objekt som är associerat med metoden.

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

Språkspecifikation för C#

Mer information finns i C#-språkspecifikationen. Språkspecifikationen är den slutgiltiga källan för C#-syntax och -användning.

Se även

  • Last updated on