Converting List<T> using covariance

I saw an interesting use of covariance today, consider an interface IMyClass and an implementing class MyClass:

   1: public interface IMyClass { }


   3: public class MyClass : IMyClass { }

If you want to convert an List<MyClass> to a List<IMyClass> you would normally use the Enumerable.Cast method but did you know that you can also use C# 4’s support for covariance in the type parameter and do this instead:

   1: var original = new List<MyClass>();


   3: var converted = original.ToList<IMyClass>()

Funky, eh? ;-)

Though I think it’s a party trick best avoided for any production code, for which you should still prefer:

   1: var converted = original.Cast<IMyClass>().ToList();


  • it achieves the same result
  • it is just as expressive
  • it is the standard way of doing this kind of conversions in LINQ
  • it is understood by most C# developers so unlikely to cause confusion

There’s another argument for using Cast, in the case of use-defined implicit/explicit operators. Imagine if you have another class which does not inherit from MyClass but defines an explicit operator which allows you to cast an instance of MyClass:

   1: public class MyOtherClass

   2: {

   3:     public static explicit operator MyClass(MyOtherClass other)

   4:     {

   5:         return new MyClass();

   6:     }

   7: }

In cases like this, you won’t be able to use the covariance trick:

   1: void Main()

   2: {

   3:     var original = new List<MyClass>();


   5:     Console.WriteLine(original.GetType());                               // List<MyClass>


   7:     // cast here doesn't actually do anything

   8:     Console.WriteLine(original.Cast<IMyClass>().ToList().GetType());     // List<IMyClass>


  10:     // changes the compile type, works because of covariance

  11:     Console.WriteLine(original.ToList<IMyClass>().GetType());            // List<IMyClass>


  13:     // casts the objs to MyOtherClass using the defined convertor

  14:     Console.WriteLine(original.Cast<MyOtherClass>().ToList().GetType()); // List<MyOtherClass>


  16:     // this line won't compile.

  17:     // it doesn't work because this is not covariance, there's no inheritance

  18:     // relationship between MyClass and MyOtherClass

  19:     // Console.WriteLine(objs.ToList<MyOtherClass>().GetType());

  20: }


StackOverflow question – Casting List<T> – covariance/contravariance problem

Leave a Comment

Your email address will not be published. Required fields are marked *