泛型和类型约束的规则

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提供“object thing”是编译器允许我做的事情，当然，我自己承担风险。

我不明白的是为什么。在.net对象中，所有内容都是全部捕获的，而运行时类型可能是盒装值或任何类型的对象。所以我看不出有什么合乎逻辑的理由让编译器区分这两种情况。我能做的最好的事情就像“程序员希望编译器使用泛型类型进行类型检查，但不使用对象”。 :)这一切都有它吗？

顺便说一句，我知道我还可以得到我的演员在美孚的情况下完成的，通过写

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

我只是想了解为什么编译器做到这一点...

Answer 1

的这里的意义是object。如果第一个例子是其他任何非object它将表现相同。基本上，你在说什么，此刻在这里：

(Bar)thing 

是：“转换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(); 
    } 
}