Чем отличается абстрактный класс от интерфейса в C#? Когда следует использовать каждый из них?

Отличие абстрактного класса от интерфейса в C#

В C# абстрактный класс и интерфейс — это ключевые механизмы для реализации принципов абстрагирования и контрактов в объектно-ориентированном программировании, но они имеют фундаментальные различия в назначении, реализации и использовании.

Основные различия

1. Определение и структура

• Абстрактный класс (abstract class):

    *   Это класс, который может содержать абстрактные методы (без реализации) и обычные методы с полной реализацией.
    *   Может иметь поля (`fields`), свойства (`properties`), конструкторы, события и любые другие члены класса.
    *   Может реализовывать интерфейсы.
    *   Не может быть инстанциирован напрямую — требует создания производного класса.

public abstract class Vehicle
{
    // Поле (возможно только в абстрактном классе)
    protected string Manufacturer;

    // Конструктор (возможно только в абстрактном классе)
    public Vehicle(string manufacturer)
    {
        Manufacturer = manufacturer;
    }

    // Абстрактный метод (без реализации)
    public abstract void Move();

    // Обычный метод с реализацией
    public virtual string GetInfo()
    {
        return $"Производитель: {Manufacturer}";
    }
}

• Интерфейс (interface):

    *   Это контракт, который определяет только сигнатуры методов, свойств, событий или индексаторов.
    *   Не может содержать реализацию методов (до C# 8.0), поля, конструкторы или статические методы с реализацией.
    *   С C# 8.0 появились возможности для default implementations методов, но это скорее исключение для обратной совместимости.

public interface IDrawable
{
    // Сигнатура метода (без реализации)
    void Draw();

    // Сигнатура свойства (без реализации)
    string Color { get; set; }

    // C# 8.0+: метод с default implementation (редко используется для новых интерфейсов)
    void DefaultDraw()
    {
        Console.WriteLine("Рисование по умолчанию");
    }
}

2. Наследование и реализация

• Класс может наследовать только от одного абстрактного класса (в силу ограничений single inheritance в C#), но может реализовывать множество интерфейсов.
• Интерфейс может наследовать от нескольких других интерфейсов, формируя сложные контракты.

// Класс наследует один абстрактный класс и реализует два интерфейса
public class Car : Vehicle, IDisposable, IComparable<Car>
{
    // Реализация абстрактного метода из Vehicle
    public override void Move()
    {
        Console.WriteLine("Автомобиль движется");
    }

    // Реализация метода из IDisposable
    public void Dispose()
    {
        // Логика освобождения ресурсов
    }

    // Реализация метода из IComparable<Car>
    public int CompareTo(Car other)
    {
        // Логика сравнения
        return 0;
    }
}

3. Семантическое назначение

• Абстрактный класс выражает "is-a" отношения (наследование сущностей). Он часто представляет базовую, частично реализованную сущность в иерархии классов, от которой логически происходят другие сущности.

    *   Пример: `Animal` -> `Mammal` -> `Dog`.

• Интерфейс выражает "can-do" отношения (способность, поведение). Он определяет набор операций, которые может выполнять объект, независимо от его основного типа.

    *   Пример: `ILogger`, `IPaymentProcessor`, `IRepository`.

Когда следует использовать каждый из них?

Использовать абстрактный класс, когда:

• Необходимо предоставить общую базовую реализацию для группы связанных классов. Например, общие поля, свойства или методы.
• Сущности в иерархии имеют четкую логическую связь "родитель-потомок". Например, Shape -> Circle, Rectangle.
• Нужно контролировать или ограничивать способ создания объектов через конструкторы в базовом классе.
• Планируется версионность и постепенное расширение базовой функциональности без изменения всех производных классов.
• Требуется объединение состояния (полей) и поведения (методов) в базовом типе.

// Пример: абстрактный класс как база для конкретных фигур с общей логикой
public abstract class Shape
{
    public string Name { get; set; } // Общее свойство

    public abstract double CalculateArea(); // Абстрактный метод

    public virtual void PrintInfo() // Общий метод с реализацией
    {
        Console.WriteLine($"Фигура: {Name}");
    }
}

Использовать интерфейс, когда:

• Нужно определить контракт для функциональности, которую могут реализовывать несвязанные классы. Например, ISerializable может реализовать Car, User, Document.
• Требуется поддержка множественного "наследования" поведения (один класс может иметь много способностей).
• Создается API или библиотека, где важно минимальное связывание (клиент зависит только от контракта, не от конкретной реализации).
• Реализуется принцип Dependency Injection и слабой связанности через, например, интерфейс IOrderService.
• Тестирование через mock-объекты — интерфейсы легко подменяются тестовыми реализациями.
• Работа с паттернами типа Strategy, Factory или Adapter, где ключевая роль — абстрагирование поведения.

// Пример: интерфейс для сервиса, который могут реализовывать разные классы
public interface IOrderService
{
    Order CreateOrder(Cart cart);
    bool ProcessPayment(Order order);
}

// Класс, не связанный с иерархией "фигур", но реализующий интерфейс
public class OnlineStoreService : IOrderService
{
    public Order CreateOrder(Cart cart)
    {
        // Логика создания заказа
        return new Order();
    }

    public bool ProcessPayment(Order order)
    {
        // Логика обработки платежа
        return true;
    }
}

Современные тенденции (C# 8.0+)

С выходом C# 8.0 интерфейсы получили возможности, ранее доступные только классам: default methods, static members, private members. Однако, их основное назначение — обеспечение обратной совместимости при расширении интерфейсов в уже существующих библиотеках. Для новых проектов рекомендуется:

• Использовать интерфейсы для чистых контрактов, когда важна только сигнатура.
• Использовать абстрактные классы для предоставления общей реализации и формирования иерархий.
• Default implementations в интерфейсах применять осторожно, только при необходимости расширения существующих интерфейсов без нарушения работы уже написанных классов.

Заключение

Выбор между абстрактным классом и интерфейсом зависит от задачи:

• Если вы моделируете родственную иерархию объектов с общим состоянием и поведением — выбирайте абстрактный класс.
• Если вы определяете набор операций или способностей, которые могут быть присущи разнородным объектам — выбирайте интерфейс.

В современных архитектурах часто используется комбинация: абстрактный класс определяет базовую сущность, а интерфейсы добавляют к ней специфические поведения, обеспечивая гибкость и соблюдение принципов SOLID (особенно Interface Segregation Principle и Dependency Inversion Principle).