virtual (odwołanie w C#)virtual (C# Reference)

Słowo kluczowe virtual służy do modyfikowania metody, właściwości, indeksatora lub deklaracji zdarzenia i umożliwia jej zastąpienie w klasie pochodnej.The virtual keyword is used to modify a method, property, indexer, or event declaration and allow for it to be overridden in a derived class. Na przykład ta metoda może zostać przesłonięta przez dowolną klasę, która ją dziedziczy:For example, this method can be overridden by any class that inherits it:

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

Implementację wirtualnego elementu członkowskiego można zmienić przez zastępujący element członkowski w klasie pochodnej.The implementation of a virtual member can be changed by an overriding member in a derived class. Aby uzyskać więcej informacji na temat używania słowa kluczowego virtual, zobacz przechowywanie wersji z przesłonięciami i nowymi słowami kluczowymi i wiedzą, kiedy używać przesłonięć i nowych słów kluczowych.For more information about how to use the virtual keyword, see Versioning with the Override and New Keywords and Knowing When to Use Override and New Keywords.

UwagiRemarks

Gdy wywoływana jest metoda wirtualna, typ czasu wykonywania obiektu jest sprawdzany dla elementu członkowskiego, który jest zastępujący.When a virtual method is invoked, the run-time type of the object is checked for an overriding member. Nadrzędny element członkowski w najbardziej pochodnej klasie jest wywoływany, który może być pierwotną składową, jeśli żadna Klasa pochodna nie przesłoni elementu członkowskiego.The overriding member in the most derived class is called, which might be the original member, if no derived class has overridden the member.

Domyślnie metody nie są wirtualne.By default, methods are non-virtual. Nie można zastąpić metody innej niż wirtualna.You cannot override a non-virtual method.

Nie można użyć modyfikatora virtual z modyfikatorami static, abstract, private lub override.You cannot use the virtual modifier with the static, abstract, private, or override modifiers. W poniższym przykładzie przedstawiono Właściwość wirtualną:The following example shows a virtual property:

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.Virtual properties behave like virtual methods, except for the differences in declaration and invocation syntax.

  • Wystąpił błąd podczas używania modyfikatora virtual właściwości statycznej.It is an error to use the virtual modifier on a static property.

  • Wirtualną Właściwość dziedziczoną można zastąpić w klasie pochodnej przez dołączenie deklaracji właściwości, która używa modyfikatora override.A virtual inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

PrzykładExample

W tym przykładzie Klasa Shape zawiera dwa współrzędne x, y i metodę wirtualną Area().In this example, the Shape class contains the two coordinates x, y, and the Area() virtual method. Różne klasy kształtu, takie jak Circle, Cylinder i Sphere dziedziczą klasę Shape, a obszar powierzchni jest obliczany dla każdego rysunku.Different shape classes such as Circle, Cylinder, and Sphere inherit the Shape class, and the surface area is calculated for each figure. Każda klasa pochodna ma własną implementację zastępującą Area().Each derived class has its own override implementation of Area().

Zwróć uwagę, że klasy dziedziczone Circle, Sphere i Cylinder używają konstruktorów, które inicjują klasę bazową, jak pokazano w poniższej deklaracji.Notice that the inherited classes Circle, Sphere, and Cylinder all use constructors that initialize the base class, as shown in the following declaration.

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

Poniższy program oblicza i wyświetla odpowiedni obszar dla każdego rysunku przez wywoływanie odpowiedniej implementacji metody Area(), zgodnie z obiektem, który jest skojarzony z metodą.The following program calculates and displays the appropriate area for each figure by invoking the appropriate implementation of the Area() method, according to the object that is associated with the method.

class TestClass
{
    public class Shape
    {
        public const double PI = Math.PI;
        protected double x, y;
        
        public Shape()
        {
        }
        
        public Shape(double x, double y)
        {
            this.x = x;
            this.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;
        }
    }

    class Sphere : Shape
    {
        public Sphere(double r) : base(r, 0)
        {
        }

        public override double Area()
        {
            return 4 * PI * x * x;
        }
    }

    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#C# language specification

Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#.For more information, see the C# Language Specification. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.The language specification is the definitive source for C# syntax and usage.

Zobacz takżeSee also