C＃中通用列表的类型转换

Question

I'm trying to figure out why the type conversion is not possible in the first case, but it is possible in the second one. Please, take a look at the code below:

var strList = new List<string>{"One", "Two", "Three"};
List<object> objList = (List<object>) strList; // <<<< why is not converted? - Case 1

IEnumerable<object> ienumList = strList; // <<<< why is converted?  - Case 2

Answer 1

While the comment referring to covariance and contravariance makes a good point about the underlying principle, I am going to answer in terms of the concrete effects in the presented case:

 List<object> objList = (List<object>) strList; 

objList is writeable. It will allow you to do this:

objList.Add(new Object());

However, objList is still the same instance as strList . You have just added an instance of System.Object to a List<string> !

The compiler cannot allow that to happen. Thus, a List<string> cannot be cast to a List<object> .

In the second case, on the other hand, you retrieve an enumerable:

 IEnumerable<object> ienumList = strList; 

There is no way to modify the resulting enumerable, as IEnumerable<T> does not provide any members that mutate the instance. Therefore, the type parameter T can be (and is) marked with the out keyword, which allows the presented typecast.

Answer 2

Two major concepts play roles here: Type Conversions and Generic Interfaces Variance . Where the variance is the leading one.

Case 1: In List<T> class definition, we do not have variance on generic parameter. So we do not have any relations defined between List<object> and List<string> . They are invariant. Therefore both implicit and explicit type conversion are not possible.

Case 2: List<T> implements IEnumerable<out T> which is covariant generic type, so List<string> can be implicitly cast to IEnumerable<object>

DETAILS:

Why the variance is not allowed for List<T> , but allowed for IEnumerable<T> ?

The point of generics is to provide compile-time type safety. Because List<T> is writable and if there wasn't a compile time check, we could write the following and have a run-time error:

List<string> stringList = new List<string>();
stringList.Add("some string"); // we are safe
List<object> objectList = stringList;
objectList.Add((new Object()); // Aargh! 
// we are trying to put an object to a list of strings!

So no unsafe variance for List<T> .

But IEnumerable<out T> is read-only. It does not provide a way to modify the referenced instance.

IEnumerable<object> objectList = new List<string>();
// we can't add a string to the objectList, 
// as `IEnumerable<out T>` is a read-only interface.

So a safe variance is possible.

Answer 3

If you are using framework 3.5 or higher, you can do this:

var strList = new List<string>{"One", "Two", "Three"};
List<object> objList = strList.Cast<object>().ToList();

You can take a look at @Hagashen Naidu it has a very good explanation for this case.

Answer 4

See the following for an explanation of co and contra-variance. Think it will give clarity on the issue you having:

http://tomasp.net/blog/variance-explained.aspx/