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

Содержание
Что такое вариативность в 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>. Но в большинстве случаев хватает ковариантного интерфейса из предыдущего раздела.
Рекомендации по безопасной работе с вариативностью
Несколько правил помогают не ошибиться при работе с коллекциями наследников:
- Используйте ковариантные интерфейсы там, где коллекцию только читают, и принимайте в параметрах самый общий подходящий тип.
- Если коллекцию нужно изменять, применяйте обобщённые методы с ограничением
where T : Baseили копируйте элементы в новый список. - Не обходите проверку типов явным приведением списков: такой код ломается во время выполнения, а не при компиляции.
Вариативность кажется сложной, но её правило простое: если тип только отдаёт значения, он может быть ковариантным, а если только принимает, контравариантным. Если же делает и то и другое, как List<T>, он остаётся инвариантным.
Частые вопросы
Почему IEnumerable ковариантен, а List нет?
IEnumerable<T> только выдаёт элементы, поэтому подмена типа на более общий безопасна. У List<T> есть методы, принимающие T, например Add, и ковариантность позволила бы добавить в список объект неподходящего типа. Поэтому для List компилятор запрещает такое присваивание.
Что означают ключевые слова in и out в объявлении интерфейса?
Модификатор out объявляет параметр типа ковариантным: он может использоваться только в возвращаемых значениях. Модификатор in делает параметр контравариантным: он допустим только во входных параметрах. Оба модификатора работают только для интерфейсов и делегатов.
Работает ли ковариантность для структур?
Нет. Вариативность обобщённых интерфейсов и делегатов работает только для ссылочных типов. Например, IEnumerable<int> нельзя присвоить переменной IEnumerable<object>, потому что для int требуется упаковка, и преобразование не является ссылочным.
Можно ли привести список наследников к списку базового типа явно?
Прямое приведение скомпилируется только через object, но во время выполнения вызовет InvalidCastException, потому что реальный тип объекта остаётся List<Derived>. Для безопасного результата создавайте копию или используйте интерфейс только для чтения.





