override (référence C#)

Le modificateur override est nécessaire pour étendre ou modifier l’implémentation abstraite ou virtuelle d’une méthode, d’une propriété, d’un indexeur ou d’un événement hérités.

Dans l’exemple suivant, la Square classe doit fournir une implémentation substituée de GetArea , car GetArea est héritée de la classe abstraite Shape :

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

Une override méthode fournit une nouvelle implémentation de la méthode héritée d’une classe de base. La méthode substituée par une déclaration override est appelée méthode de base substituée. Une override méthode doit avoir la même signature que la méthode de base substituée. À compter de C# 9,0, les méthodes prennent en charge les types de override retour covariants. En particulier, le type de retour d’une override méthode peut dériver du type de retour de la méthode de base correspondante. Dans C# 8,0 et les versions antérieures, les types de retour d’une override méthode et la méthode de base substituée doivent être identiques.

Vous ne pouvez pas surcharger une méthode statique ou non virtuelle. La méthode de base substituée doit être virtual, abstract ou override.

Une déclaration override ne peut pas changer l’accessibilité de la méthode virtual. Les deux méthodes override et virtual doivent avoir le même override.

Vous ne pouvez pas utiliser les modificateurs new, static ou virtual pour modifier une méthode override.

Une déclaration de propriété de substitution doit spécifier exactement le même modificateur d’accès, le même type et le même nom que la propriété héritée. À compter de C# 9,0, les propriétés de substitution en lecture seule prennent en charge les types de retour covariants. La propriété substituée doit être virtual , abstract ou override .

Pour plus d’informations sur l’utilisation du mot clé override, consultez override et Savoir quand utiliser les mots clés override et new. Pour plus d’informations sur l’héritage, consultez Héritage.

Exemple

Cet exemple définit une classe de base nommée Employee et une classe dérivée nommée SalesEmployee. La classe SalesEmployee inclut un champ supplémentaire (salesbonus) et substitue la méthode CalculatePay afin de la prendre en compte.

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

spécification du langage C#

Pour plus d’informations, consultez la section méthodes de substitution de la spécification du langage C#.

Pour plus d’informations sur les types de retour covariants, consultez la Remarque relativeà la proposition de fonctionnalité.

Voir aussi