Polimorfismo

El polimorfismo suele considerarse el tercer pilar de la programación orientada a objetos, después de la encapsulación y la herencia. Polimorfismo es una palabra griega que significa "con muchas formas" y tiene dos aspectos diferentes:

• En tiempo de ejecución, los objetos de una clase derivada se pueden tratar como objetos de una clase base en lugares como parámetros de método y colecciones o matrices. Cuando se produce este polimorfismo, el tipo declarado del objeto ya no es idéntico a su tipo en tiempo de ejecución.
• Las clases base pueden definir e implementar métodosvirtuales, y las clases derivadas pueden invalidarlos, lo que significa que proporcionan su propia definición e implementación. En tiempo de ejecución, cuando el código de cliente llama al método, CLR busca el tipo en tiempo de ejecución del objeto e invoca esa invalidación del método virtual. En el código fuente puede llamar a un método en una clase base y hacer que se ejecute una versión del método de la clase derivada.

Los métodos virtuales permiten trabajar con grupos de objetos relacionados de manera uniforme. Por ejemplo, supongamos que tiene una aplicación de dibujo que permite a un usuario crear varios tipos de formas en una superficie de dibujo. En tiempo de compilación, no sabe qué tipos de formas en concreto creará el usuario. Sin embargo, la aplicación tiene que realizar el seguimiento de los distintos tipos de formas que se crean, y tiene que actualizarlos en respuesta a las acciones del mouse del usuario. Para solucionar este problema en dos pasos básicos, puede usar el polimorfismo:

1. Crear una jerarquía de clases en la que cada clase de forma específica deriva de una clase base común.
2. Usar un método virtual para invocar el método apropiado en una clase derivada mediante una sola llamada al método de la clase base.

Primero, cree una clase base llamada Shape y clases derivadas como Rectangle, Circle y Triangle. Dé a la clase Shape un método virtual llamado Draw e invalídelo en cada clase derivada para dibujar la forma determinada que la clase representa. Cree un objeto List<Shape> y agréguele una instancia de Circle, Triangle y Rectangle.

public class Shape
{
    // A few example members
    public int X { get; init; }
    public int Y { get; init; }
    public int Height { get; init; }
    public int Width { get; init; }

    // Virtual method
    public virtual void Draw()
    {
        Console.WriteLine("Performing base class drawing tasks");
    }
}

public class Circle : Shape
{
    public override void Draw()
    {
        // Code to draw a circle...
        Console.WriteLine("Drawing a circle");
        base.Draw();
    }
}
public class Rectangle : Shape
{
    public override void Draw()
    {
        // Code to draw a rectangle...
        Console.WriteLine("Drawing a rectangle");
        base.Draw();
    }
}
public class Triangle : Shape
{
    public override void Draw()
    {
        // Code to draw a triangle...
        Console.WriteLine("Drawing a triangle");
        base.Draw();
    }
}

Para actualizar la superficie de dibujo, use un bucle foreach para iterar por la lista y llamar al método Draw en cada objeto Shape de la lista. Aunque cada objeto de la lista tenga un tipo declarado de Shape, se invocará el tipo en tiempo de ejecución (la versión invalidada del método en cada clase derivada).

// Polymorphism at work #1: a Rectangle, Triangle and Circle
// can all be used wherever a Shape is expected. No cast is
// required because an implicit conversion exists from a derived
// class to its base class.
List<Shape> shapes =
[
    new Rectangle(),
    new Triangle(),
    new Circle()
];

// Polymorphism at work #2: the virtual method Draw is
// invoked on each of the derived classes, not the base class.
foreach (var shape in shapes)
{
    shape.Draw();
}
/* Output:
    Drawing a rectangle
    Performing base class drawing tasks
    Drawing a triangle
    Performing base class drawing tasks
    Drawing a circle
    Performing base class drawing tasks
*/

En C#, cada tipo es polimórfico porque todos los tipos, incluidos los definidos por el usuario, heredan de Object.

Introducción al polimorfismo

Miembros virtuales

Cuando una clase derivada hereda de una clase base, incluye todos los miembros de la clase base. Todo el comportamiento declarado en la clase base forma parte de la clase derivada. Esto permite que los objetos de la clase derivada se traten como objetos de la clase base. Los modificadores de acceso (public, protected, private, etc.) determinan si esos miembros son accesibles desde la implementación de la clase derivada. Los métodos virtuales proporcionan al diseñador diferentes opciones para el comportamiento de la clase derivada:

• La clase derivada puede invalidar los miembros virtuales en la clase base, definiendo un nuevo comportamiento.
• La clase derivada puede heredar el método de clase base más cercano sin invalidarlo, conservando el comportamiento existente, pero permitiendo que otras clases derivadas invaliden el método.
• La clase derivada puede definir una nueva implementación no virtual de los miembros que ocultan las implementaciones de clase base.

Una clase derivada puede invalidar un miembro de la clase base si este se declara como virtual o abstracto. El miembro derivado debe usar la palabra clave override para indicar explícitamente que el propósito del método es participar en una invocación virtual. El siguiente fragmento de código muestra un ejemplo:

public class BaseClass
{
    public virtual void DoWork() { }
    public virtual int WorkProperty => 0;
}
public class DerivedClass : BaseClass
{
    public override void DoWork() { }
    public override int WorkProperty
    {
        get { return 0; }
    }
}

Los campos no pueden ser virtuales; solo pueden serlo los métodos, propiedades, eventos e indizadores. Cuando una clase derivada invalida un miembro virtual, se llama a ese miembro aunque se acceda a una instancia de esa clase como una instancia de la clase base. El siguiente fragmento de código muestra un ejemplo:

DerivedClass B = new();
B.DoWork();  // Calls the new method.

BaseClass A = B;
A.DoWork();  // Also calls the new method.

Los métodos y propiedades virtuales permiten a las clases derivadas extender una clase base sin necesidad de usar la implementación de clase base de un método. Para obtener más información, consulte Control de versiones con las palabras clave Override y New. Una interfaz proporciona otra manera de definir un método o conjunto de métodos cuya implementación se deja a las clases derivadas.

Ocultación de miembros de clase base con miembros nuevos

Si quiere que la clase derivada tenga un miembro con el mismo nombre que el de un miembro de una clase base, puede usar la palabra clave new para ocultar el miembro de clase base. La new palabra clave se coloca antes del tipo de valor devuelto de un miembro de clase que se va a reemplazar. El siguiente fragmento de código muestra un ejemplo:

public class BaseClass
{
    public void DoWork() { WorkField++; }
    public int WorkField;
    public int WorkProperty
    {
        get { return 0; }
    }
}

public class DerivedClass : BaseClass
{
    public new void DoWork() { WorkField++; }
    public new int WorkField;
    public new int WorkProperty
    {
        get { return 0; }
    }
}

Al usar la new palabra clave , va a crear un método que oculte el método de clase base en lugar de reemplazarlo . Esto es diferente de los métodos virtuales. La ocultación de método hace que el método llamado dependa del tipo de la variable en tiempo de compilación, no del tipo en tiempo de ejecución del objeto.

Se puede acceder a los miembros de clase base ocultos desde el código de cliente mediante la conversión de la instancia de la clase derivada a una instancia de la clase base. Por ejemplo:

DerivedClass B = new();
B.DoWork();  // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork();  // Calls the old method.

En este ejemplo, ambas variables hacen referencia a la misma instancia de objeto, pero el método al que se llama depende del tipo declarado de la variable: DerivedClass.DoWork() cuando se accede a través de la DerivedClass variable y BaseClass.DoWork() cuando se accede a través de la BaseClass variable.

Evasión de que las clases derivadas invaliden los miembros virtuales

Los miembros virtuales permanecen virtuales, independientemente de cuántas clases se declaren entre el miembro virtual y la clase que la declaró originalmente. Si la clase A declara un miembro virtual, y la clase B deriva de A, y la clase C deriva de B, la clase C hereda el miembro virtual y podría sobreescribirlo, independientemente de si la clase B declaró una sobreescritura para ese miembro. El siguiente fragmento de código muestra un ejemplo:

public class A
{
    public virtual void DoWork() { }
}
public class B : A
{
    public override void DoWork() { }
}

Una clase derivada puede detener la herencia virtual al declarar una invalidación como sealed. Para detener la herencia, es necesario colocar la palabra clave sealed antes de la palabra clave override en la declaración del miembro de la clase. El siguiente fragmento de código muestra un ejemplo:

public class C : B
{
    public sealed override void DoWork() { }
}

En el ejemplo anterior, el método DoWork ya no es virtual para ninguna clase que se derive de C. Sigue siendo virtual para las instancias de C, aunque se conviertan al tipo B o al tipo A. Los métodos sellados se pueden reemplazar por clases derivadas mediante la palabra clave new, como se muestra en el ejemplo siguiente:

public class D : C
{
    public new void DoWork() { }
}

En este caso, si se llama a DoWork en D con una variable de tipo D, se llama a la nueva instancia de DoWork. Si se utiliza una variable de tipo C, B o A para acceder a una instancia de D, una llamada a DoWork sigue las reglas de la herencia virtual, enrutando esas llamadas a la implementación de DoWork en la clase C.

Acceso a miembros virtuales de clases base desde clases derivadas

Una clase derivada que reemplaza o invalida un método o una propiedad todavía puede tener acceso al método o la propiedad en la clase base mediante la base palabra clave . El siguiente fragmento de código muestra un ejemplo:

public class Base
{
    public virtual void DoWork() {/*...*/ }
}
public class Derived : Base
{
    public override void DoWork()
    {
        //Perform Derived's work here
        //...
        // Call DoWork on base class
        base.DoWork();
    }
}

Para obtener más información, vea base.

Nota

Se recomienda que los miembros virtuales usen base para llamar a la implementación de clase base de ese miembro en su propia implementación. Dejar que se produzca el comportamiento de la clase base permite a la clase derivada concentrarse en implementar el comportamiento específico de la clase derivada. Si no se llama a la implementación de la clase base, es hasta la clase derivada para que su comportamiento sea compatible con el comportamiento de la clase base.