为什么当我投一个类来它并没有实现一个接口编译器错误？ [英] Why no compiler error when I cast a class to an interface it doesn't implement?

问题描述

如果我尝试从一个类的无效强制转换为一个接口，那么编译器不会抱怨（在运行时出现错误）;它的确实的不过抱怨，如果我尝试了类似的强制转换为抽象类。

If I try an invalid cast from a class to an interface, then the compiler doesn't complain (the error occurs at runtime); it does complain, however, if I try a similar cast to an abstract class.

class Program
{
    abstract class aBaz
    {
        public abstract int A { get; }
    }

    interface IBar
    {
        int B { get; }
    }

    class Foo
    {
        public int C { get; }
    }

    static void Main()
    {
        Foo foo = new Foo();

        // compiler error, as expected, since Foo doesn't inherit aBaz
        aBaz baz = (aBaz)foo;

        // no compiler error, even though Foo doesn't implement IBar
        IBar bar = (IBar)foo;
    }
}

为什么不拒绝编译自投富的到的伊巴尔的，当它的（貌似？）无效？或者，翻转的问题，如果编译器允许这种无效投投抽象类的 aBaz 伊巴尔的，为什么没有让类似的无效 EM>？

Why doesn't the compiler reject the cast from Foo to IBar, when it's (seemingly?) invalid? Or, to flip the question, if the compiler allows this "invalid" cast to the interface IBar, why doesn't it allow the similar "invalid" cast to the abstract class aBaz?

推荐答案

您需要了解的.Net的继承体系明白为什么这是有道理的。在.NET中，一个类只能从一个基类继承，但可以实现任意数量的接口。

You need to understand the inheritance system of .Net to see why this makes sense. In .Net, a class may inherit from only one base class but may implement any number of interfaces.

class Program
{
    abstract class aBaz
    {
        public abstract int A { get; }
    }

    interface IBar
    {
        int B { get; }
    }

    class Foo
    {
        public int C { get; }
    }

    class BarableFoo : Foo, IBar
    {
        public int C { get; }
    }

    static void Main()
    {
        // This is why the compiler doesn't error on the later cast
        Foo foo = new BarableFoo();

        // compiler error: aBaz is a class and the compiler knows that
        // Foo is not a _subclass_ of aBaz.
        aBaz baz = (aBaz)foo;

        // no compiler error: the class Foo does not implement IBar, however at runtime
        // this instance, "foo", might be a subclass of Foo that _implements_ IBar.
        // This is perfectly valid, and succeeds at runtime.
        IBar bar = (IBar)foo;

        // On the other hand...
        foo = new Foo();

        // This fails at runtime as expected. 
        bar = (IBar)foo;
    }

}

在非常简单原始的例子这个问题，好像编译器可以检测到富的这个实例是永远不会被强制转换为伊巴尔，但更多的是一种最好有的警告不是语言的正确性的问题。

In the extremely simple original example in the question, it seems like the compiler could detect that this instance of foo is never going to be castable to IBar, but that is more of a "nice to have" warning than a matter of language correctness.

这篇关于为什么当我投一个类来它并没有实现一个接口编译器错误？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！