virtual (odwołanie w C#)

  • Artykuł

Słowo virtual kluczowe służy do modyfikowania metody, właściwości, indeksatora lub deklaracji zdarzenia i zezwalania na jej zastąpienie w klasie pochodnej. Na przykład tę metodę można zastąpić dowolną klasą, która ją dziedziczy:

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

Implementacja wirtualnego elementu członkowskiego może zostać zmieniona przez zastępowanie elementu członkowskiego w klasie pochodnej. Aby uzyskać więcej informacji na temat używania słowa kluczowego virtual , zobacz Przechowywanie wersji za pomocą przesłonięć i nowych słów kluczowych oraz Informacje o tym, kiedy należy użyć przesłonięć i nowych słów kluczowych.

Uwagi

Po wywołaniu metody wirtualnej typ czasu wykonywania obiektu jest sprawdzany pod kątem zastępowania elementu członkowskiego. Wywoływana jest przesłonięta składowa w najbardziej pochodnej klasie, która może być pierwotną składą, jeśli żadna klasa pochodna nie zastąpi składowej.

Domyślnie metody nie są wirtualne. Nie można zastąpić metody innej niż wirtualna.

Modyfikatora nie można używać virtual z modyfikatorami static, abstract, privatelub override . W poniższym przykładzie przedstawiono właściwość wirtualną:

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

Właściwości wirtualne zachowują się jak metody wirtualne, z wyjątkiem różnic w składni deklaracji i wywołania.

  • Jest to błąd podczas używania virtual modyfikatora we właściwości statycznej.

  • Właściwość dziedziczona wirtualnie może zostać zastąpiona w klasie pochodnej przez dołączenie deklaracji właściwości, która używa override modyfikatora.

Przykład

W tym przykładzie Shape klasa zawiera dwie współrzędne x, yi metodę wirtualną Area() . Różne klasy kształtów, takie jak Circle, Cylinderi Sphere dziedziczą klasę Shape , a obszar powierzchni jest obliczany dla każdego rysunku. Każda klasa pochodna ma własną implementację Area()zastąpienia klasy .

Zwróć uwagę, że dziedziczone klasy Circle, Cylinderi Sphere wszystkie używają konstruktorów, które inicjują klasę bazową, jak pokazano w poniższej deklaracji.

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

Poniższy program oblicza i wyświetla odpowiedni obszar dla każdego rysunku Area() , wywołując odpowiednią implementację metody, zgodnie z obiektem skojarzonym z metodą .

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

specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.

Zobacz też