Casting generic interfaces and classes in C# [duplicate]

Question

Possible Duplicate:
Question about C# covariance

Why does the code compile in the first case, but doesn't compile in the second one?

class ClassA {
}

class ClassB : ClassA {
}

static void Main() {
    var classAList = new List<ClassA>();
    var classBList = new List<ClassB>();

    IEnumerable<ClassA> classAIEnumerable;
    IEnumerable<ClassB> classBIEnumerable = new List<ClassB>();

    // First case:
    classAIEnumerable = classBIEnumerable;

    // Second case:
    classAList = classBList;
}

What does prevent code to compile in the second case? Why can't compiler figure out that this casting is safe?

Answer 1

List<T> is not covarient because it does not define T as an out type unlike IEnumerable<out T>. It is also not contravarient because it does not define T as an in.

If that cast were allowed then you could add a class C to it:

class ClassC : ClassA { 
} 

// Second case: 
classAList = classBList; //suppose this is allowed
ClassA myC = new ClassC();
classAList.Add(myC); //Whoops! we've added a ClassC to the list which is actually a list of ClassBs

http://msdn.microsoft.com/en-us/library/ee207183.aspx