Ошибки и их решения

Ковариантность и вариативность списков в C#

4 мин чтения

Присвоить List<Derived> переменной типа List<Base> в C# нельзя, хотя Derived наследуется от Base. Причина в том, что List<T> инвариантен, и так компилятор защищает вас от ошибок типов во время выполнения. Ниже разобраны ковариантность и контравариантность и несколько безопасных способов решить задачу.

Ковариантность и вариативность списков в C#
Содержание
  1. Что такое вариативность в C#
  2. Почему список List инвариантен
  3. Ковариантные интерфейсы
  4. Если нужен именно изменяемый список
  5. Рекомендации по безопасной работе с вариативностью
  6. Частые вопросы

Что такое вариативность в C#

Вариативность описывает, можно ли использовать конструкцию с одним типом там, где ожидается конструкция с родственным типом. Ковариантность сохраняет направление наследования: если Derived наследуется от Base, то и IEnumerable<Derived> можно использовать как IEnumerable<Base>. Ту же идею применяют к возвращаемым значениям: метод может вернуть более конкретный тип, чем объявлен.

public class Base { }
public class Derived : Base { }

public class BaseFactory
{
    public virtual Base Create() => new Base();
}

public class DerivedFactory : BaseFactory
{
    // Начиная с C# 9 переопределение может вернуть более конкретный тип
    public override Derived Create() => new Derived();
}

Контравариантность работает в обратную сторону: конструкцию с общим типом можно использовать там, где ожидается конструкция с более конкретным. Классический пример - делегат Action<in T>: обработчик любого объекта Base подходит как обработчик Derived.

Action<Base> handleBase = b => Console.WriteLine(b.GetType().Name);
Action<Derived> handleDerived = handleBase; // контравариантность
handleDerived(new Derived());

Обычная передача объекта Derived в метод, принимающий Base, вариативностью не является. Это обычный полиморфизм, который работает всегда.

Почему список List инвариантен

Классы, в том числе List<T>, в C# инвариантны по параметру типа. Поэтому следующий код не компилируется:

List<Derived> derivedList = new List<Derived>();
List<Base> baseList = derivedList; // Ошибка компиляции CS0029

Запрет защищает от ошибок. Если бы присваивание разрешили, через переменную baseList можно было бы добавить в список объект другого наследника Base, например OtherDerived. Тогда список, созданный для Derived, содержал бы объект чужого типа, и сбой произошёл бы позже в совсем другом месте программы. Для массивов ковариантность разрешена, но проверка переносится на время выполнения и приводит к ArrayTypeMismatchException.

Ковариантные интерфейсы

Если коллекцию нужно только читать, достаточно использовать ковариантный интерфейс: IEnumerable<T>, IReadOnlyList<T> или IReadOnlyCollection<T>. Они объявлены с модификатором out, и начиная с C# 4.0 поддерживают ковариантность.

IEnumerable<Derived> derivedCollection = new List<Derived>();
IEnumerable<Base> baseCollection = derivedCollection; // работает

IReadOnlyList<Base> readOnlyBase = new List<Derived>(); // тоже работает

Здесь это безопасно, потому что интерфейсы только отдают элементы наружу и не принимают новые. Значит, добавить в коллекцию объект неподходящего типа невозможно. Поэтому, когда метод только читает данные, лучше принимать IEnumerable<Base> или IReadOnlyList<Base>, а не List.

Если нужен именно изменяемый список

Первое решение - создать новый список с копией элементов. Это просто, но изменения в новом списке не отразятся в исходном.

List<Base> baseList = new List<Base>(derivedList);
// или
List<Base> baseList2 = derivedList.Cast<Base>().ToList();

Второе решение - сделать метод обобщённым с ограничением типа. Тогда он работает с исходным списком любого наследника и даже может его изменять, не нарушая типобезопасности.

public static void AddItems<T>(List<T> list, Func<T> factory)
    where T : Base
{
    list.Add(factory());
}

AddItems(derivedList, () => new Derived());

Если необходимо передавать в разные места представление исходного списка, можно написать собственную обёртку, которая реализует IReadOnlyList<Base> и делегирует вызовы внутреннему List<Derived>. Но в большинстве случаев хватает ковариантного интерфейса из предыдущего раздела.

Рекомендации по безопасной работе с вариативностью

Несколько правил помогают не ошибиться при работе с коллекциями наследников:

  1. Используйте ковариантные интерфейсы там, где коллекцию только читают, и принимайте в параметрах самый общий подходящий тип.
  2. Если коллекцию нужно изменять, применяйте обобщённые методы с ограничением where T : Base или копируйте элементы в новый список.
  3. Не обходите проверку типов явным приведением списков: такой код ломается во время выполнения, а не при компиляции.

Вариативность кажется сложной, но её правило простое: если тип только отдаёт значения, он может быть ковариантным, а если только принимает, контравариантным. Если же делает и то и другое, как List<T>, он остаётся инвариантным.

Частые вопросы

Почему IEnumerable ковариантен, а List нет?

IEnumerable<T> только выдаёт элементы, поэтому подмена типа на более общий безопасна. У List<T> есть методы, принимающие T, например Add, и ковариантность позволила бы добавить в список объект неподходящего типа. Поэтому для List компилятор запрещает такое присваивание.

Что означают ключевые слова in и out в объявлении интерфейса?

Модификатор out объявляет параметр типа ковариантным: он может использоваться только в возвращаемых значениях. Модификатор in делает параметр контравариантным: он допустим только во входных параметрах. Оба модификатора работают только для интерфейсов и делегатов.

Работает ли ковариантность для структур?

Нет. Вариативность обобщённых интерфейсов и делегатов работает только для ссылочных типов. Например, IEnumerable<int> нельзя присвоить переменной IEnumerable<object>, потому что для int требуется упаковка, и преобразование не является ссылочным.

Можно ли привести список наследников к списку базового типа явно?

Прямое приведение скомпилируется только через object, но во время выполнения вызовет InvalidCastException, потому что реальный тип объекта остаётся List<Derived>. Для безопасного результата создавайте копию или используйте интерфейс только для чтения.