Cannot convert from List to List

Question

I\'m trying to pass A list of DerivedClass to a function that takes a list of BaseClass, but I get the error:

cannot convert from 
         


        

Answer 1

When you have a class derived from a base class, any containers of those classes are not automatically derived. So you cannot just cast a List<Derived> to a List<Base>.

Use .Cast<T>() to create a new list where each object is cast back to the base class:

List<MyDerived> list1 = new List<MyDerived>();
List<MyBase> list2 = list1.Cast<MyBase>().ToList();

Note that this is a new list, not a cast version of your original list, so operations on this new list will not reflect on the original list. Operations on the contained objects will reflect, however.

Answer 2

Explanations that I have found have simply said that it violates type safety somehow, but I'm not seeing it. What is the risk of the compiler allowing conversion from List<DerivedClass> to List<BaseClass>?

This question is asked almost every day.

A List<Mammal> cannot be converted to a List<Animal> because you can put a lizard into a list of animals. A List<Mammal> cannot be converted to a List<Giraffe> because there might be a tiger in the list already.

Therefore List<T> has to be invariant in T.

However, List<Mammal> can be converted to IEnumerable<Animal> (as of C# 4.0) because there is no method on IEnumerable<Animal> that adds a lizard. IEnumerable<T> is covariant in T.

Answer 3

If you could write

List<BaseClass> bcl = new List<DerivedClass>(); 

you could call

var instance = new AnotherClassInheritingFromBaseClass();
bc1.Add(instance);

Adding an instance which is not a DerivedClass to the list.

Answer 4

The behavior you're describing is called covariance – if A is B, then List<A> is List<B>.

However, for mutable types like List<T>, that is fundamentally unsafe.

Had this been possible, the method would be able to add a new OtherDerivedClass() to a list that can actually only hold DerivedClass.

Covariance is safe on immutable types, although .Net only supports it in interfaces and delegates.
If you change the List<T> parameter to IEnumerable<T>, that will work

Answer 5

It is because List<T> is in-variant, not co-variant, so you should change to IEnumerable<T> which supports co-variant, it should work:

IEnumerable<BaseClass> bcl = new List<DerivedClass>();
public void doSomething(IEnumerable<BaseClass> bc)
{
    // do something with bc
}

Information about co-variant in generic

Answer 6

A solution i used was to create an extension class:

public static class myExtensionClass 
{
    public void doSomething<T>(List<BaseClass> bc) where T: BaseClass
    {
        // do something with bc
    }
}

It uses generic, but when you call it you don't have to especify the class since you already 'told' the compiler the type is the same of extended class.

You would call it this way:

List<DerivedClass> lst = new List<DerivedClass>();
lst.doSomething();