Clases abstractas en C#: métodos abstractos, ejemplos y comparación con las interfaces

Una clase abstracta es una clase que solo existe para que otras deriven de ella. No puede instanciarse, y puede declarar miembros abstractos: métodos y propiedades sin cuerpo que toda clase derivada concreta debe implementar. En todo lo demás es una clase normal: puede tener campos, constructores y métodos totalmente implementados que heredan las clases derivadas.

Declarar una clase abstracta

Marca la clase como abstract, y marca como abstract cada miembro que deban aportar las clases derivadas, terminándolo con un punto y coma en lugar de un cuerpo:

using System;
using System.Collections.Generic;

abstract class Shape
{
    public string Label { get; }

    protected Shape(string label) { Label = label; }

    public abstract double Area();              // no body: each shape must implement it
    public abstract double Perimeter();

    public string Describe() =>                 // shared, concrete method
        $"{Label}: area {Area():F2}, perimeter {Perimeter():F2}";
}

class Circle : Shape
{
    private readonly double radius;
    public Circle(double radius) : base("Circle") { this.radius = radius; }

    public override double Area() => Math.PI * radius * radius;
    public override double Perimeter() => 2 * Math.PI * radius;
}

class Rectangle : Shape
{
    private readonly double width, height;
    public Rectangle(double w, double h) : base("Rectangle") { width = w; height = h; }

    public override double Area() => width * height;
    public override double Perimeter() => 2 * (width + height);
}

class Program
{
    static void Main()
    {
        var shapes = new List<Shape> { new Circle(1.5), new Rectangle(4, 2.5) };
        foreach (Shape s in shapes)
            Console.WriteLine(s.Describe());

        // var s2 = new Shape("blob"); // error CS0144: Cannot create an instance of the abstract type or interface 'Shape'
    }
}

Salida:

Circle: area 7.07, perimeter 9.42
Rectangle: area 10.00, perimeter 13.00

Describe se escribe una sola vez, en la clase base, y llama a Area y a Perimeter, que ni siquiera existen en Shape. Esa es la idea de un miembro abstracto: la clase base puede contar con él, y el compilador garantiza que toda forma concreta lo proporciona. Una clase derivada que olvida uno no compila:

class Triangle : Shape
{
    public Triangle() : base("Triangle") { }
    public override double Area() => 6;
}
// error CS0534: 'Triangle' does not implement inherited abstract member 'Shape.Perimeter()'

La solución es implementar Perimeter, o marcar Triangle como abstract si es una base intermedia para otras clases.

Reglas de los miembros abstractos

• Un miembro abstracto no tiene cuerpo y es implícitamente virtual: las clases derivadas lo implementan con override.
• Solo las clases abstractas pueden contener miembros abstractos. Poner uno en una clase normal es un error de compilación.
• Los miembros abstractos no pueden ser private (nadie podría sobrescribirlos) ni static en una clase.
• Los métodos, las propiedades, los indexadores y los eventos pueden ser abstractos. Los campos y los constructores no.
• Una clase abstracta no tiene por qué contener ningún miembro abstracto. Marcar una clase como abstract sin más solo impide instanciarla, lo que resulta útil para una clase base que solo tiene sentido a través de sus subclases.

Una propiedad abstracta declara qué accesores debe proporcionar la clase derivada:

abstract class Plan
{
    public abstract decimal MonthlyPrice { get; }
    public abstract string Name { get; }
}

class ProPlan : Plan
{
    public override decimal MonthlyPrice => 12.99m;
    public override string Name => "Pro";
}

Constructores en las clases abstractas

Una clase abstracta puede tener constructores. No pueden llamarse con new, pero cada constructor derivado ejecuta uno mediante : base(...), así que son el sitio donde se inicializa y valida el estado compartido. Decláralos protected, que dice exactamente eso: solo las clases derivadas pueden usar esto.

El patrón template method

La razón más habitual para escribir una clase abstracta es fijar el orden de un algoritmo en la clase base y dejar que las clases derivadas rellenen los pasos concretos. El método base que ejecuta los pasos no es virtual, así que ninguna subclase puede reordenarlos ni saltárselos.

using System;
using System.Collections.Generic;
using System.Text;

abstract class OrderExporter
{
    // The template: the steps and their order are fixed here.
    public string Export(IEnumerable<(string Item, int Qty, decimal Price)> rows)
    {
        var sb = new StringBuilder();
        sb.Append(Header());
        decimal total = 0;
        foreach (var r in rows)
        {
            sb.Append(Row(r.Item, r.Qty, r.Price));
            total += r.Qty * r.Price;
        }
        sb.Append(Footer(total));
        return sb.ToString();
    }

    protected abstract string Header();
    protected abstract string Row(string item, int qty, decimal price);
    protected virtual string Footer(decimal total) => "";   // optional step with a default
}

class CsvExporter : OrderExporter
{
    protected override string Header() => "item,qty,price\n";
    protected override string Row(string item, int qty, decimal price) => $"{item},{qty},{price}\n";
}

class MarkdownExporter : OrderExporter
{
    protected override string Header() => "| Item | Qty | Price |\n| --- | --- | --- |\n";
    protected override string Row(string item, int qty, decimal price) => $"| {item} | {qty} | {price} |\n";
    protected override string Footer(decimal total) => $"\nTotal: {total}\n";
}

class Program
{
    static void Main()
    {
        var rows = new List<(string, int, decimal)> { ("Coffee beans", 2, 11.50m), ("Filter papers", 1, 3.20m) };

        OrderExporter[] exporters = { new CsvExporter(), new MarkdownExporter() };
        foreach (var e in exporters)
            Console.Write(e.Export(rows) + "\n");
    }
}

Salida:

item,qty,price
Coffee beans,2,11.50
Filter papers,1,3.20

| Item | Qty | Price |
| --- | --- | --- |
| Coffee beans | 2 | 11.50 |
| Filter papers | 1 | 3.20 |

Total: 26.20

Cada fila es una tupla con nombre, y la salida se construye con un StringBuilder. Fíjate en la mezcla: Header y Row son abstract porque todo formato debe decidirlos, y Footer es virtual con un valor por defecto vacío porque la mayoría de los formatos no necesitan nada ahí. Los pasos son protected, así que el código externo solo puede llamar a Export. Las clases del framework usan la misma idea: Stream y TextWriter son clases base abstractas cuyos muchos métodos de conveniencia se construyen sobre unos pocos miembros que aporta una clase derivada (Read y Write en un stream, Write(char) en un text writer).

Clase abstracta frente a interfaz

Las dos permiten escribir código contra un tipo sin conocer la clase concreta. Se diferencian en lo que pueden contener y en cuántas puede tener una clase:

Los métodos de interfaz por defecto (C# 8) redujeron la distancia, pero no la diferencia esencial:

public interface ILogger
{
    void Write(string message);
    void Error(string message) => Write("ERROR: " + message);   // default implementation: C# 8, .NET Core 3.0+
}

Un método por defecto sigue sin poder tocar campos de instancia, porque la interfaz no tiene ninguno; solo puede llamar a otros miembros de la interfaz.

Una forma práctica de elegir:

• Interfaz cuando describes una capacidad que pueden tener tipos sin relación entre sí (IComparable<T>, IDisposable, IShippingProvider), cuando los structs deben poder participar, o cuando una clase necesita varios de esos papeles. La mayor parte del código de inyección de dependencias se escribe contra interfaces por este motivo.
• Clase abstracta cuando los tipos derivados son de verdad variaciones de una misma cosa y comparten estado o un algoritmo fijo, como los exportadores de arriba.
• Las dos es algo habitual: una interfaz de la que dependen los que llaman, y una clase base abstracta que la implementa y ahorra a los que implementan reescribir las partes compartidas. La página de interfaces trata en detalle el lado de las interfaces.

Errores comunes

• Intentar instanciar la clase base. new Shape(...) es CS0144. Instancia una clase derivada.
• Olvidar override en la implementación. Escribir public double Area() en la clase derivada no implementa el miembro abstracto; el compilador da CS0534 por la implementación que falta, más un aviso de que el método nuevo oculta al heredado.
• Un constructor público en una clase abstracta. No hace daño pero confunde. Usa protected.
• Clases abstractas sin código compartido. Si la clase base solo tiene miembros abstractos y ningún estado, una interfaz dice lo mismo y no gasta el único hueco de clase base.
• Llamar a miembros abstractos desde el constructor base. La implementación derivada se ejecuta antes del cuerpo del constructor derivado, así que los campos que asigna ese cuerpo siguen siendo 0 o null.