为什么C＃编译器允许在IEnumerable <T>和TAlmostAnything之间进行显式转换？

Question

The following code gives you a compiler error, as you'd expect:

List<Banana> aBunchOfBananas = new List<Banana>();

Banana justOneBanana = (Banana)aBunchOfBananas;

However, when using IEnumerable<Banana> , you merely get a runtime error.

IEnumerable<Banana> aBunchOfBananas = new List<Banana>();

Banana justOneBanana = (Banana)aBunchOfBananas;

Why does the C# compiler allow this?

Answer 1

I would suppose it's because IEnumerable<T> is an interface where some implementation could have an explicit cast to Banana - no matter how silly that would be.

On the other hand, the compiler knows that List<T> can't be explicitly cast to a Banana .

Nice choice of examples, by the way!

Adding an example to clarify. Maybe we'd have some "enumerable" that should always contain at most a single Banana :

public class SingleItemList<T>:Banana, IEnumerable<T> where T:Banana {
    public static explicit operator T(SingleItemList<T> enumerable) {
        return enumerable.SingleOrDefault();
    }

    // Others omitted...
}

Then you could actually do this:

IEnumerable<Banana> aBunchOfBananas = new SingleItemList<Banana>();
Banana justOneBanana = (Banana)aBunchOfBananas;

As it's the same as writing the following, which the compiler is perfectly happy with:

Banana justOneBanana = aBunchOfBananas.SingleOrDefault();

Answer 2

When you say Y y = (Y)x; this cast says to the compiler "trust me, whatever x is, at runtime it can be casted to a Y , so, just do it, okay?"

But when you say

List<Banana> aBunchOfBananas = new List<Banana>();
Banana justOneBanana = (Banana)aBunchOfBananas;

the compiler can look at the definitions for each of these concrete classes ( Banana and List<Banana> ) and see that there is no static explicit operator Banana(List<Banana> bananas) defined (remember, an explicit cast must be defined in either the type being casted or the type being casted to, this is from the spec, section 17.9.4). It knows at compile time that what you're saying can not ever be true. So it yells at you to stop lying.

But when you say

IEnumerable<Banana> aBunchOfBananas = new List<Banana>();
Banana justOneBanana = (Banana)aBunchOfBananas;

well, now the compiler doesn't know. It very well could the case that whatever aBunchOfBananas happens to be at run time, its concrete type X could have defined static explicit operator Banana(X bananas) . So the compiler trusts you, like you asked it to.

Answer 3

这可能是因为编译器知道 Banana没有扩展List<T> ，但是实现IEnumerable<T>某个对象也可能会扩展Banana并使其成为有效的强制转换。

Answer 4

According to language spec (6.2.4) "The explicit reference conversions are: From any class-type S to any interface-type T, provided S is not sealed and provided S does not implement T ... The explicit reference conversions are those conversions between reference-types that require run-time checks to ensure they are correct..."

So compiler doesn't check interface realization during compilation. It does CLR in runtime. It checks metadata trying to find realization in class or among its parents. I dunno why it behaves like this. Probably it takes a lot of time. So this code compiles correctly:

public interface IInterface
{}

public class Banana
{
}

class Program
{
    static void Main( string[] args )
    {
        Banana banana = new Banana();

        IInterface b = (IInterface)banana;
    }
}

In other hand if we try to cast banana to class, compiler checks its metadata and throw an error:

 FileStream fs = (FileStream)banana;