convert generic type to base class

Question

public class Base {...}

public class Complex: Base {...}

public class MyOtherClass<T> {...}

and a list of the two type

List<MyOtherClass<Complex>> listOfComplex
List<MyOtherClass<Base>> listOfBase

I want have a list

listOfComplex.Union(listOfBase)

but i cant convert generic of a type to a generic of another type even if Complex derive fro Base It's possibble to have a list of a base class?

Answer 1

Although Complex derives from Base, there is no such relationship between MyOtherClass<Complex> and MyOtherClass<Base>. That is the reason why you cannot create an Union of the two lists. For the framework both generic types are completely different.

The solution now really depends on what exactly your class does. Check out the topic of covariance and contravariance here in Docs - these are two special cases in which you will be permitted to create conversions between the two generic types if the types either are input or output only.

You could also add custom cast or manually cast the items to the "base" type before doing the "union" operation.

Answer 2

Because that's how Covariance and Contravariance in Generics works, specifically invariance, it means that you can use only the type originally specified; so an invariant generic type parameter is neither covariant nor contravariant.

You can't assign an instance of List<Base> to a variable of type List<Complex> or in the opposite direction. Same applies to custom generic classes. There is no implicit conversion that compiler could use in order to convert types.

Even if you add generic type constraint. A<B> and A<C> are two different types with no conversion between them even if C is inherited from B (because AC is not inherited from AB)

Answer 3

@MartinZikmund has explained why it does not work. The resolution to this kind of problem is to either derive the generic classes from a non-generic base class or to let them implement a common interface.

    public class MyOtherClassBase { }
    public class MyOtherClass<T> : MyOtherClassBase { }

Then you can specify MyOtherClassBase as generic parameter to Union explicitly. Now, Union will expect inputs of type IEnumerable<MyOtherClassBase>. Lists of type List<MyOtherClass<T>> are assignment compatible to IEnumerable<MyOtherClassBase>.

var result = listOfComplex.Union<MyOtherClassBase>(listOfBase);

Note the out keyword in the declaration

public interface IEnumerable<out T> : System.Collections.IEnumerable

It makes the interface covariant. See also SO question <out T> vs <T> in Generics and especially Reed Copsey's answer.

Answer 4

You should specify in your generic that T is a class base on Type :

public class MyOtherClass<T> where T : Base {...}

T will be accepted only if derive from Base And Union will should work

Here some documentation about Generics, thanks to @Marie:

https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/constraints-on-type-parameters