泛型规则和类型约束

Question

出于好奇，为什么编译器对待不受约束的泛型类型与 typeof(object) 有任何不同？

class Bar { }

class Foo
{
    void foo(object thing)
    {
        ((Bar)thing).ToString();
    }
}

class Foo<T>
{
    void foo(T thing)
    {
        ((Bar)thing).ToString();
    }
}

在上面，将“T thing”转换为 Bar 会导致编译器错误。然而，将“对象事物”转换为 Bar 是编译器允许我做的事情，当然风险自负。

我不明白为什么。毕竟在 .net 中的对象是一个包罗万象的对象，运行时类型可以是装箱的值或任何类型的对象。所以我看不出编译器有什么逻辑理由来区分这两种情况。我能做的最好的事情是“程序员希望编译器对泛型类型进行类型检查，而不是对对象进行类型检查”。 :) 仅此而已吗？

顺便说一句，我知道我仍然可以在 Foo 案例中完成我的演员表，只需编写

((Bar)(object)thing).ToString();

我只是想了解编译器为什么会这样......

Answer 1

这里的意义是object。如果第一个示例是 object 以外的任何内容，则其行为将相同。基本上，你现在在这里说的是：

(Bar)thing

is: "将T 转换为Bar";在一般情况下，这远不合法。通过添加object 即可：

(Bar)(object)thing

这是“将T 转换为object...” - 这始终是合法的，因为object 是所有托管类型的根；并注意这可能涉及一个框 - “......然后将object 转换为Bar” - 再次；它在编译时总是合法的，并且在运行时涉及类型检查（“unbox-any”）。

例如：假设T 是DateTime...

DateTime thing = ...
Bar bar = (Bar)(object)thing;

完全有效；确定它会在运行时失败，但是：这是您需要牢记的场景。

Answer 2

它归结为创建泛型的语义和目的。如果你有一个通用类型 T，编译器不会让你随意将它直接强制转换为任何其他对象。这是有道理的，因为 T 的目的是强制程序员指定 T 实际上是什么类型。它不会是“对象”，而是特定类型的对象。在编译时，编译器无法知道 T 中的内容，因此无法强制转换。

从对象进行强制转换是因为它是一个匿名对象 - 与在其使用中定义的 KNOWN 对象类型相反。

这可以使用“where”子句进行扩展。例如，您可以指定 T 必须是 IBar 类型；

interface IBar { }

class Bar : IBar { }

class Foo<T>
    where T : IBar
{
    void foo(T thing)
    {
        ((IBar)thing).ToString();
    }
}

继承也适用于 where 子句；

class Bar { }

class Foo<T>
    where T : Bar
{
    void foo(T thing)
    {
        // now you don't need to cast at all as the compiler knows
        // exactly what type T is (at a parent level at least)
        thing.ToString();
    }
}