I have a few classes:
class Vehicle
{
}
class Car : Vehicle
{
}
I have a list of the derived class:
IList
You're facing the problem that there is limited co- and contravariance in C#. There is an interesting approach in C# 4.0, described here at the very ending. However, it creates some other limitations that are related to the truck-problem in the answer from Novelocrat.
If you must use IList
all of the way, then you are out of luck and the answers above can help you. However, if you can use an IList
that is casted as IEnumerable
and then simply re-casted at the destination as IList
, that would work, since IEnumerable
can accept such practice.
// At the source or at the model.
IEnumerable<BaseType> list = new List<Type>();
// At the destination.
IList<BaseType> castedList = (IList<BaseType>)list;
Although, since the compiler cannot enforce these things, you must manually make sure that the types and base types indeed match, of course.
Note that IReadOnlyList<T>
from .NET 4.5+ will allow you to cast IReadOnlyList<Car>
into IReadOnlyList<Vehicle>
with no problems. List<T>
and Collection<T>
implement this interface.
That sort of polymorphism that lets you cast IList<Car>
to IList<Vehicle>
is unsafe, because it would let you insert a Truck
in your IList<Car>
.
var vehicles = cars.OfType<IVehicle>()
Use IEnumerable<T>.Cast :
IList<Vehicle> vehicles = cars.Cast<Vehicle>().ToList();
Alternatively, you may be able to avoid the conversion to List depending on how you wish to process the source car list.