C# 为什么可以'；我使用'；as'；是否使用约束为接口的泛型类型参数？

在下面的示例中（仅用于演示目的），如果

T

不受类约束，则此转换：

var ret = objectA as T;

..将导致以下编译错误：

类型参数“T”不能与“as”运算符一起使用，因为 它既没有类类型约束，也没有“类”约束

我不明白为什么我不能这样做。由于我已将

T

约束为接口

ioobject

，编译器应该知道

T

必须是接口类型，并且

as

操作应该有效

public interface IObject
{
    string Id { get; set; }
}
public class ObjectA : IObject
{
    public string Id { get; set; }
}
public class ObjectFactory
{
    public T CreateObject<T>(string id) where T : IObject
    {
        ObjectA objectA = new ObjectA();
        var x = objectA as IObject; // this is good
        var ret = objectA as T; // why this 'as' cannot compile?
        return ret;
    }
    public T CreateClassObject<T>(string id) where T : class, IObject
    {
        ObjectA objectA = new ObjectA();
        var ret = objectA as T; // if T is class, this 'as' can compile
        return ret;
    }
}

公共接口对象
{
字符串Id{get；set；}
}
公共类对象A:IOObject
{
公共字符串Id{get；set；}
}
公共类对象工厂
{
公共T CreateObject（字符串id），其中T:IOObject
{
ObjectA ObjectA=新ObjectA（）；
var x=objectA作为ioobject；//这很好
var ret=objectA as T；//为什么这个“as”不能编译？
返回ret；
}
公共T CreateClassObject（字符串id），其中T:class，IOObject
{
ObjectA ObjectA=新ObjectA（）；
var ret=objectA as T；//如果T是类，则可以编译此“as”
返回ret；
}
}

因为我已经将T约束为接口IOObject，所以编译器应该知道T必须是接口类型，“as”操作应该有效

public interface IObject
{
    string Id { get; set; }
}
public class ObjectA : IObject
{
    public string Id { get; set; }
}
public class ObjectFactory
{
    public T CreateObject<T>(string id) where T : IObject
    {
        ObjectA objectA = new ObjectA();
        var x = objectA as IObject; // this is good
        var ret = objectA as T; // why this 'as' cannot compile?
        return ret;
    }
    public T CreateClassObject<T>(string id) where T : class, IObject
    {
        ObjectA objectA = new ObjectA();
        var ret = objectA as T; // if T is class, this 'as' can compile
        return ret;
    }
}

否，

T

不必是接口类型。它必须是实现接口的类型。考虑：

public struct Foo : IObject
{
    public string Id { get; set; }
}

现在，您希望

CreateObject（“ff”）

做什么

对于

CreateObject

上的

class

约束，该调用将无效，因为

Foo

不是引用类型-编译器知道

t

是引用类型，所以

objectA as t

是可以的