override (C#-Referenz)

Der override-Modifizierer wird benötigt, um die abstrakte oder virtuelle Implementierung einer geerbten Methode, Eigenschaft, eines Indexers oder Ereignisses zu erweitern oder ändern.

Im folgenden Beispiel muss die Square-Klasse eine überschriebene Implementierung von GetArea bereitstellen, weil GetArea von der abstrakten Klasse Shape geerbt wird:

abstract class Shape
{
    public abstract int GetArea();
}

class Square : Shape
{
    private int _side;

    public Square(int n) => _side = n;

    // GetArea method is required to avoid a compile-time error.
    public override int GetArea() => _side * _side;

    static void Main()
    {
        var sq = new Square(12);
        Console.WriteLine($"Area of the square = {sq.GetArea()}");
    }
}
// Output: Area of the square = 144

Eine override-Methode stellt eine neue Implementierung der Methode bereit, die von einer Basisklasse geerbt wurde. Die Methode, die durch eine override-Deklaration überschrieben wird, wird als die überschriebene Basismethode bezeichnet. Eine override-Methode muss dieselbe Signatur wie die überschriebene Basismethode haben. Ab C# 9.0 unterstützen override-Methoden kovariante Rückgabetypen. Dies bedeutet, dass der Rückgabetyp einer override-Methode vom Rückgabetyp der entsprechenden Basismethode abgeleitet werden kann. In C# 8.0 und früher müssen die Rückgabetypen einer override-Methode und die der überschriebenen Basismethode identisch sein.

Sie können keine nicht virtuelle oder statische Methode überschreiben. Die überschriebene Basismethode muss virtual, abstract oder override sein.

Ein override-Deklaration kann nicht die Erreichbarkeit auf die virtual Methode ändern. Sowohl die Methode override als auch virtual müssen den gleichen Zugriffsebenenmodifizierer besitzen.

Sie können die Modifizierer new, static oder virtual nicht verwenden, um eine override-Methode zu ändern.

Eine überschreibende Eigenschaftsdeklaration muss genau denselben Zugriffsmodifizierer, Typ und Namen wie die geerbte Eigenschaft angeben. Ab C# 9.0 unterstützen schreibgeschützte überschreibende Eigenschaften kovariante Rückgabetypen. Die überschriebene Eigenschaft muss virtual, abstract oder override entsprechen.

Weitere Informationen zur Verwendung des override-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?. Weitere Informationen zur Vererbung in C# finden Sie unter Vererbung.

Beispiel

In diesem Beispiel wird eine Basisklasse namens Employee und eine abgeleitete Klasse namens SalesEmployee definiert. Die SalesEmployee-Klasse enthält ein zusätzliches Feld salesbonus, und überschreibt die CalculatePay-Methode, um dies zu berücksichtigen.

class TestOverride
{
    public class Employee
    {
        public string Name { get; }

        // Basepay is defined as protected, so that it may be
        // accessed only by this class and derived classes.
        protected decimal _basepay;

        // Constructor to set the name and basepay values.
        public Employee(string name, decimal basepay)
        {
            Name = name;
            _basepay = basepay;
        }

        // Declared virtual so it can be overridden.
        public virtual decimal CalculatePay()
        {
            return _basepay;
        }
    }

    // Derive a new class from Employee.
    public class SalesEmployee : Employee
    {
        // New field that will affect the base pay.
        private decimal _salesbonus;

        // The constructor calls the base-class version, and
        // initializes the salesbonus field.
        public SalesEmployee(string name, decimal basepay, decimal salesbonus)
            : base(name, basepay)
        {
            _salesbonus = salesbonus;
        }

        // Override the CalculatePay method
        // to take bonus into account.
        public override decimal CalculatePay()
        {
            return _basepay + _salesbonus;
        }
    }

    static void Main()
    {
        // Create some new employees.
        var employee1 = new SalesEmployee("Alice", 1000, 500);
        var employee2 = new Employee("Bob", 1200);

        Console.WriteLine($"Employee1 {employee1.Name} earned: {employee1.CalculatePay()}");
        Console.WriteLine($"Employee2 {employee2.Name} earned: {employee2.CalculatePay()}");
    }
}
/*
    Output:
    Employee1 Alice earned: 1500
    Employee2 Bob earned: 1200
*/

C#-Sprachspezifikation

Weitere Informationen finden Sie im Abschnitt override-Methoden der Sprachspezifikation für C#.

Weitere Informationen zu kovarianten Rückgabetypen finden Sie im Hinweis zum Featurevorschlag.

Siehe auch