泛型类方法返回值为何需两次强制转换？B→T失败B→A→T可行

问题场景 #

在.NET 6环境下，定义泛型类MyClass<T>（T约束为基类A），希望GetElem方法返回与类实例同类型的新对象。当T为派生类B时，直接使用return (T) new B(1, true);会触发CS0030错误，但通过两次强制转换return (T) (A) new B(1, true);却能正常运行。

完整代码 #

using NUnit.Framework;
namespace Tests;

[TestFixture]
public class TestInheritance
{
    private class A
    {
        private int _a;
        
        public A(int a)
            => _a = a;
    }

    private class B : A
    {
        private bool _b;
        
        public B(int a, bool b) : base(a)
            => _b = b;
    }

    private class MyClass<T> where T : A
    {
        public T? GetElem()
        {
            if (typeof(T) == typeof(A))
            {
                return (T) new A(1);
            }
            if (typeof(T) == typeof(B))
            {
                // Works
                return  (T) (A) new B(1, true);
                // Does not work
                // return (T) new B(1, true);
            }
            return null;
        }
    }

    [Test]
    public void TestClass()
    {
        var myA = new MyClass<A>();
        var elemA = myA.GetElem();
        var myB = new MyClass<B>();
        var elemB = myB.GetElem();
        
        Assert.NotNull(elemA);
        Assert.AreEqual(elemA.GetType(), typeof(A));
        Assert.NotNull(elemB);
        Assert.AreEqual(elemB.GetType(), typeof(B));
    }
}

错误信息 #

TestInheritance.cs(39, 24): [CS0030] Cannot convert type 'Tests.TestInheritance.B' to 'T'

原因解析 #

直接转换失败的原因 #

编译器做静态类型检查时，只会参考泛型约束：T是A的子类，但它无法确定T具体是哪个子类——哪怕你在代码里用typeof(T) == typeof(B)做了运行时判断，编译器的静态检查不会考虑这个条件分支。

对编译器来说，T可能是A的任意子类（比如另一个未定义的C类），而B和T之间没有明确的继承关系（T不一定是B或B的子类），因此不允许直接将B强制转换为T，触发CS0030错误。

两次转换可行的原因 #

1. 第一步new B(1, true)转换为A：这是合法的隐式向上转换，因为B继承自A，编译器完全认可这种转换。
2. 第二步从A转换为T：由于T的约束是A的子类，编译器允许这种显式向下转换——虽然这种转换在运行时可能因类型不匹配抛出异常，但编译器只做静态检查，而你已经通过typeof(T)的判断保证了运行时类型的正确性，所以转换能正常执行。

内容的提问来源于stack exchange，提问作者Adam Streck