Абстрактные классы в C#: абстрактные методы, примеры и сравнение с интерфейсом

Абстрактный класс это класс, который существует только для того, чтобы от него наследовались. Его экземпляр нельзя создать, и он может объявлять абстрактные члены: методы и свойства без тела, которые должен реализовать каждый конкретный производный класс. Во всём остальном это обычный класс: у него могут быть поля, конструкторы и полностью реализованные методы, которые наследуют производные классы.

Объявление абстрактного класса

Пометьте класс abstract и пометьте abstract каждый член, который должны предоставить производные классы, закончив его точкой с запятой вместо тела:

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'
    }
}

Вывод:

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

Describe написан один раз, в базовом классе, и вызывает Area и Perimeter, которых в Shape вообще нет. В этом и смысл абстрактного члена: базовый класс может на него полагаться, а компилятор гарантирует, что каждая конкретная фигура его предоставит. Производный класс, который забыл один из них, не компилируется:

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

Исправление: реализовать Perimeter или пометить сам Triangle как abstract, если это промежуточный базовый класс для других классов.

Правила для абстрактных членов

• У абстрактного члена нет тела, и он неявно виртуальный: производные классы реализуют его через override.
• Абстрактные члены могут содержать только абстрактные классы. Такой член в обычном классе это ошибка компиляции.
• Абстрактные члены не могут быть private (никто не смог бы их переопределить) или static в классе.
• Абстрактными могут быть методы, свойства, индексаторы и события. Поля и конструкторы не могут.
• Абстрактный класс не обязан содержать ни одного абстрактного члена. Пометка класса abstract сама по себе просто запрещает создание экземпляров, что полезно для базового класса, имеющего смысл только через подклассы.

Абстрактное свойство объявляет, какие методы доступа должен предоставить производный класс:

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";
}

Конструкторы в абстрактных классах

У абстрактного класса могут быть конструкторы. Их нельзя вызвать через new, но каждый конструктор производного класса выполняет один из них через : base(...), поэтому именно в них инициализируется и проверяется общее состояние. Объявляйте их protected, что говорит ровно это: использовать их могут только производные классы.

Шаблонный метод

Самая частая причина писать абстрактный класс это зафиксировать порядок алгоритма в базовом классе и дать производным классам заполнить отдельные шаги. Базовый метод, выполняющий шаги, не виртуальный, поэтому ни один подкласс не может переставить или пропустить их.

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");
    }
}

Вывод:

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

Каждая строка это именованный кортеж, а вывод собирается через StringBuilder. Обратите внимание на сочетание: Header и Row абстрактные, потому что каждый формат должен определить их сам, а Footer виртуальный с пустой реализацией по умолчанию, потому что большинству форматов там ничего не нужно. Шаги protected, поэтому внешний код может вызвать только Export. Классы фреймворка используют ту же идею: Stream и TextWriter это абстрактные базовые классы, многие удобные методы которых построены на нескольких членах, предоставляемых производным классом (Read и Write для потока, Write(char) для средства записи текста).

Абстрактный класс или интерфейс

Оба позволяют писать код для типа, не зная конкретного класса. Различаются они тем, что могут содержать и сколько их может быть у класса:

Методы интерфейса по умолчанию (C# 8) сократили разрыв, но не главное различие:

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

Метод по умолчанию всё равно не может обращаться к полям экземпляра, потому что у интерфейса их нет; он может только вызывать другие члены интерфейса.

Практический способ выбора:

• Интерфейс, когда вы описываете возможность, которая может быть у несвязанных типов (IComparable<T>, IDisposable, IShippingProvider), когда в этом должны участвовать структуры или когда классу нужно несколько таких ролей. По этой причине большая часть кода с внедрением зависимостей пишется для интерфейсов.
• Абстрактный класс, когда производные типы действительно являются вариациями одного и того же и разделяют состояние или фиксированный алгоритм, как экспортёры выше.
• Оба это обычное сочетание: интерфейс, от которого зависят вызывающие, и абстрактный базовый класс, который его реализует и избавляет реализующих от переписывания общих частей. Сторона интерфейсов подробно описана на странице об интерфейсах.

Частые ошибки

• Попытка создать экземпляр базового класса. new Shape(...) это CS0144. Создавайте экземпляр производного класса.
• Забытый override в реализации. Запись public double Area() в производном классе не реализует абстрактный член; компилятор сообщает CS0534 об отсутствующей реализации плюс предупреждение, что новый метод скрывает унаследованный.
• Открытый конструктор у абстрактного класса. Безвредно, но вводит в заблуждение. Используйте protected.
• Абстрактные классы без общего кода. Если в базовом классе только абстрактные члены и нет состояния, интерфейс скажет то же самое и не займёт единственное место для базового класса.
• Вызов абстрактных членов из базового конструктора. Реализация производного класса выполняется до тела его конструктора, поэтому поля, которые присваивает это тело, всё ещё равны 0 или null.