override (Referencia de C#)

El modificador override es necesario para ampliar o modificar la implementación abstracta o virtual de un método, propiedad, indexador o evento heredado.

En el siguiente ejemplo, la clase Square debe proporcionar una implementación invalidada de GetArea, ya que GetArea se hereda de la clase abstracta 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

Un método override proporciona una nueva implementación de un método heredado de una clase base. El método invalidado por una declaración override se conoce como método base invalidado. Un método override debe tener la misma signatura que el método base invalidado. A partir de C# 9.0, los métodos override admiten tipos de valor devuelto covariantes. En concreto, el tipo de valor devuelto de un método override puede derivar del tipo de valor devuelto del método base correspondiente. En C# 8.0 y versiones anteriores, los tipos de valor devuelto de un método override y el método base invalidado deben ser iguales.

No se puede invalidar un método estático o no virtual. El método base invalidado debe ser virtual, abstract o override.

Una declaración override no puede cambiar la accesibilidad del método virtual. El método override y el método virtual deben tener el mismo modificador de nivel de acceso.

No se pueden usar los modificadores new, static o virtual para modificar un método override.

Una declaración de propiedad de invalidación debe especificar exactamente el mismo modificador de acceso, tipo y nombre que la propiedad heredada,. A partir de C# 9.0, las propiedades de invalidación de solo lectura admiten tipos de valor devuelto covariantes. La propiedad invalidada debe ser virtual, abstract u override.

Para obtener más información sobre cómo usar la palabra clave override, vea Control de versiones con las palabras clave Override y New y Saber cuándo usar las palabras clave Override y New (Guía de programación de C#). Para obtener información sobre la herencia, vea Herencia.

Ejemplo

En este ejemplo se define una clase base denominada Employee y una clase derivada denominada SalesEmployee. La clase SalesEmployee incluye un campo adicional, salesbonus, e invalida el método CalculatePay para tenerlo en cuenta.

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

Especificación del lenguaje C#

Para obtener más información, vea la sección Métodos de invalidación de Especificación del lenguaje C#.

Para obtener más información sobre tipos de valor devuelto covariantes, vea la nota de propuesta de características.

Vea también