virtual (C#-referens)

  • Artikel

Nyckelordet virtual används för att ändra en metod, egenskap, indexerare eller händelsedeklaration och tillåta att den åsidosättas i en härledd klass. Den här metoden kan till exempel åsidosättas av vilken klass som helst som ärver den:

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

Implementeringen av en virtuell medlem kan ändras av en övergripande medlem i en härledd klass. 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.

Kommentarer

När en virtuell metod anropas kontrolleras körningstypen för objektet efter en övergripande medlem. Den överordnade medlemmen i den mest härledda klassen anropas, vilket kan vara den ursprungliga medlemmen, om ingen härledd klass har åsidosatt medlemmen.

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

Du kan inte använda virtual modifieraren med staticmodifierarna , abstract, privateeller override . I följande exempel visas en virtuell egenskap:

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

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

  • Det är ett fel att använda modifieraren på virtual en statisk egenskap.

  • 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, yoch 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().

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

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