Question

昨天偶然发现了这个奇怪的情况，其中t as D返回非空值，但(D)t导致编译错误。

由于我匆忙，我只是使用t as D并继续使用，但我很好奇为什么演员表无效，因为t确实是D。任何人都可以解释为什么编译器不喜欢演员吗？

class Program
{
    public class B<T> where T : B<T> { }

    public class D : B<D> { public void M() { Console.Out.WriteLine("D.M called."); } }

    static void Main() { M(new D()); }

    public static void M<T>(T t) where T : B<T>
    {
        // Works as expected: prints "D.M called."
        var d = t as D;
        if (d != null)
            d.M();

        // Compiler error: "Cannot cast expression of type 'T' to type 'D'."
        // even though t really is a D!
        if (t is D)
            ((D)t).M();
    }
}

编辑：在游戏中，我认为这是一个更清晰的例子。在这两种情况下，t都被限制为B，可能是D。但是泛型的情况不会编译。在确定演员表是否合法时，C＃是否会忽略通用约束？即使它确实忽略它，t仍可能是D;那么为什么这是编译时错误而不是运行时异常？

class Program2
{
    public class B { }

    public class D : B { public void M() { } }

    static void Main()
    {
        M(new D());
    }

    public static void M(B t)
    {
        // Works fine!
        if (t is D)
            ((D)t).M();
    }

    public static void M<T>(T t) where T : B
    {
        // Compile error!
        if (t is D)
            ((D)t).M();
    }
}

Answer 1

在第二个例子中，您可以更改

((D)t).M();

到

((D)((B)t)).M();

您可以从B投射到D，但不一定要从“B”投射到D。 “B”可能是A，例如A : B。

当您可能在层次结构中从子级跳转到子级时，会出现编译器错误。您可以在层次结构中进行强制转换，但不能对其进行强制转换。

((D)t).M();       // potentially across, if t is an A
((D)((B)t)).M();  // first up the hierarchy, then back down

另请注意，如果((D)((B)t)).M();实际上不是t，您仍可能会在D时遇到运行时错误。（你的is检查应该可以防止这种情况。）

（另请注意，编译器在任何情况下都不会考虑if (t is D)检查。）

最后一个例子：

class Base { }
class A : Base { }
class C : Base { }

...
A a = new A();
C c1 = (C)a;         // compiler error
C c2 = (C)((Base)a); // no compiler error, but a runtime error (and a resharper warning)

// the same is true for 'as'
C c3 = a as C;           // compiler error
C c4 = (a as Base) as C; // no compiler error, but always evaluates to null (and a resharper warning)

Answer 2

将其更改为

public static void M<T>(T t) where T : D

如果您想强制T必须是D类型，这是适当的限制。

如果您的限制将T定义为T的D，则无法编译。

例如：您无法投射List<int> to int，反之亦然

Answer 3

您的模板函数有一个约束，要求T为B<T>。

因此，当您的编译器尝试将t类型的对象T转换为D时，它无法执行此操作。因为T被保证为B<T>，而不是D。

如果您添加约束以要求T为D，则此功能将起作用。即where T: B<T>, D或简称where T: D，它也保证T为B<T>，因为继承链。

问题的第二部分：当你调用t as D时，它会在运行时被检查。并且，在运行时，使用多态，验证t可以转换为D类型，并且没有错误。

注意：顺便说一下，这段代码太奇怪了。你确定你在做什么吗？

当`x as Y`工作正常时，为什么这个演员表无效？

3 个答案: