override (Riferimenti per C#)

Il modificatore override è necessario per estendere o modificare l'implementazione astratta o virtuale di un metodo, una proprietà, un indicizzatore o un evento ereditato.

Nell'esempio riportato di seguito la classe Square deve fornire un'implementazione sottoposta a override di Area poiché Area è ereditata dalla classe astratta ShapesClass:

abstract class ShapesClass
{
    abstract public int Area();
}

class Square : ShapesClass
{
    int x, y;
    // Because ShapesClass.Area is abstract, failing to override
    // the Area method would result in a compilation error.
    public override int Area()
    {
        return x * y;
    }
}

Per ulteriori informazioni sull'utilizzo della parola chiave override, vedere Controllo delle versioni con le parole chiave Override e New e Sapere quando utilizzare le parole chiave Override e New.

Note

Un metodo di override fornisce una nuova implementazione di un membro ereditato da una classe base. Il metodo di cui è stato eseguito l'override mediante una dichiarazione di override viene definito metodo di base sottoposto a override. Il metodo di base sottoposto a override deve avere la stessa firma del metodo di override. Per informazioni sull'ereditarietà, vedere Ereditarietà.

Non è possibile eseguire l'override di un metodo non virtuale o static. Il metodo di base sottoposto a override deve essere virtual, abstract o override.

Le dichiarazioni override non possono modificare l'accessibilità del metodo virtual. Il metodo di override e il metodo virtual devono avere lo stesso modificatore del livello di accesso.

Non è possibile utilizzare i modificatori new, static, virtual o abstract per modificare un metodo di override.

Una dichiarazione di proprietà di override deve indicare esattamente lo stesso modificatore di accesso, lo stesso tipo e lo stesso nome della proprietà ereditata. Inoltre, la proprietà sottoposta a override deve essere virtual, abstract o override.

Esempio

Nell'esempio riportato di seguito vengono definite una classe base denominata Employee e una classe derivata denominata SalesEmployee. La classe SalesEmployee comprende una proprietà aggiuntiva, salesbonus, ed esegue l'override del metodo CalculatePay per considerarla.

using System;
class TestOverride
{
    public class Employee
    {
        public string name;

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

        // Constructor to set the name and basepay values.
        public Employee(string name, decimal basepay)
        {
            this.name = name;
            this.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)
        {
            this.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.
        SalesEmployee employee1 = new SalesEmployee("Alice", 
                      1000, 500);
        Employee employee2 = new Employee("Bob", 1200);

        Console.WriteLine("Employee " + employee1.name + 
                  " earned: " + employee1.CalculatePay());
        Console.WriteLine("Employee " + employee2.name + 
                  " earned: " + employee2.CalculatePay());
    }
}

Output

Employee Alice earned: 1500
Employee Bob earned: 1200

Specifiche del linguaggio C#

Per ulteriori informazioni, vedere le sezioni riportate di seguito in Specifiche del linguaggio C#:

• 1.6.5.4 Metodi virtuali, di override e astratti

• 10.5.4 Metodi di override

Vedere anche

Riferimenti

Ereditarietà (Guida per programmatori C#)
Parole chiave di C#
Modificatori (Riferimenti per C#)
abstract (Riferimenti per C#)
virtual (Riferimenti per C#)
new (Riferimenti per C#)

Concetti

Guida per programmatori C#
Polimorfismo (Guida per programmatori C#)

Altre risorse

Riferimenti per C#