virtual (C#-Referenz)virtual (C# Reference)

Das Schlüsselwort virtual wird zum Ändern einer Methoden-, Eigenschaften-, Indexer- oder Ereignisdeklaration verwendet, und lässt zu, dass sie in einer abgeleiteten Klasse außer Kraft gesetzt werden.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. Diese Methode kann z.B. von jeder Klasse, die sie erbt, überschrieben werden:For example, this method can be overridden by any class that inherits it:

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

Die Implementierung eines virtuellen Members kann durch einen overriding member (überschreibender Member) in einer abgeleiteten Klasse geändert werden.The implementation of a virtual member can be changed by an overriding member in a derived class. Weitere Informationen zur Verwendung des virtual-Schlüsselworts finden Sie unter Versionsverwaltung mit den Schlüsselwörtern „override“ und „new“ und Wann müssen die Schlüsselwörter „override“ und „new“ verwendet werden?.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.

HinweiseRemarks

Wenn eine virtuelle Methode aufgerufen wird, wird der Laufzeittyp des Objekts auf einen überschreibenden Member überprüft.When a virtual method is invoked, the run-time type of the object is checked for an overriding member. Der überschreibende Member in der abgeleitetsten Klasse (bei dem es sich um den ursprünglichen Member handeln könnte) wird aufgerufen, wenn keine abgeleitete Klasse den Member außer Kraft gesetzt hat.The overriding member in the most derived class is called, which might be the original member, if no derived class has overridden the member.

Standardmäßig sind Methoden nicht virtuell.By default, methods are non-virtual. Sie können keine nicht virtuelle Methode überschreiben.You cannot override a non-virtual method.

Sie können keine der virtual Modifizierer mit der static, abstract, private, oder override Modifizierer.You cannot use the virtual modifier with the static, abstract, private, or override modifiers. Im folgenden Beispiel wird eine virtuelle Methode gezeigt: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 (value != String.Empty)
            {
                name = value;
            }
            else
            {
                name = "Unknown";
            }
        }
    }

}

Virtuelle Eigenschaften verhalten sich wie abstrakte Methoden – sie unterscheiden sich lediglich in der Deklarations- und Aufrufsyntax.Virtual properties behave like abstract methods, except for the differences in declaration and invocation syntax.

  • Es ist unzulässig, den virtual-Modifizierer für eine statische Eigenschaft zu verwenden.It is an error to use the virtual modifier on a static property.

  • Eine virtuelle vererbte Eigenschaft kann in einer abgeleiteten Klasse mithilfe der Eigenschaftendeklaration, die den Modifizierer override verwendet, außer Kraft gesetzt werden.A virtual inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

BeispielExample

In diesem Beispiel enthält die Klasse Shape die zwei Koordinaten x und y und die virtuelle Methode Area().In this example, the Shape class contains the two coordinates x, y, and the Area() virtual method. Andere Formklassen, z.B. Circle, Cylinder und Sphere erben die Klasse Shape. Die Oberfläche wird für jede Abbildung berechnet.Different shape classes such as Circle, Cylinder, and Sphere inherit the Shape class, and the surface area is calculated for each figure. Jede abgeleitete Klasse verfügt über Ihre eigene Überschreibungsimplementierung von Area().Each derived class has it own override implementation of Area().

Beachten Sie, dass die geerbten Klassen Circle, Sphere und Cylinder alle Konstruktoren verwenden, die die Basisklasse initialisieren, wie in der folgenden Deklaration gezeigt.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) {}  

Das folgende Programm berechnet und zeigt den entsprechenden Bereich für jede Abbildung durch Aufruf der entsprechenden Implementierung der Area()-Methode gemäß dem Objekt, das der Methode zugeordnet ist.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
    */

C#-ProgrammiersprachenspezifikationC# Language Specification

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Siehe auchSee Also

C#-ReferenzC# Reference
C#-ProgrammierhandbuchC# Programming Guide
ModifiziererModifiers
C#-SchlüsselwörterC# Keywords
PolymorphismusPolymorphism
abstractabstract
overrideoverride
newnew