子类的通用类型不允许父类

Question

给定这样的结构：

class Parent { }

class Child : Parent { }

我有一个方法，它采用泛型类型，并带有对象类型为 Child 的约束，

static void doSomething<T>() where T : Child
{
    if (typeof(T) == typeof(Parent))
    {
        /* ... */
    }
    else if (typeof(T) == typeof(Child))
    {
        /* ... */
    }
}

唯一的问题是，如果我有：

class implementsParent : Parent { }

class implementsChild : Child { }

使用 ImplementsParent 类型调用泛型方法将不起作用：

doSomething<implementsParent>(); // compile error
doSomething<implementsChild>(); // works fine

我我正在尝试解决重载通用方法不考虑约束的事实。

我在这里能做什么？

@Sander Rijken：附加信息。

我需要使用泛型类型来调用 ORM 框架方法，如下所示：

static void doSomething<T>() where T : Child
{
    if (typeof(T) == typeof(Parent))
    {
        Parent obj = orm.GetObject<T>(criteria);
    }
    else if (typeof(T) == typeof(Child))
    {
        Child obj = orm.GetObject<T>(criteria);
    }
}

约束位于 T : Parent 会导致 Child obj = orm.GetObject() 中断，因为 T 无法转换为类型“Child”

@Richard Hein：

最初，我有 2 个方法，每个方法都对子/父之一有约束（在本例中：来自 DevExpress ORM 的 XPObject 和 XPCustomObject - XPObject 继承自 XPCustomObject）。

这些方法如下所示：（

static void removeBlank<T>(UnitOfWork uow) where T : XPObject
{
    T blank = uow.GetObjectByKey<T>(0):
    if (blank != null)
    {
        blank.Delete();
        uow.CommitChanges();
    }
}

在本例中）使用 XPCustomObject 来拥有 Short 类型的 PK（而不是 XPObject 上的默认 int）。所以唯一的变化是获取对象的调用：

static void removeBlankCustomObject<T>(UnitOfWork uow) where T : XPCustomObject
{
    T blank = uow.GetObjectByKey<T>((short)0);    
    if (blank != null)
    {
        blank.Delete();
        uow.CommitChanges();
    }
}

差异很小，所以我想将这两个方法合并在一起。

Answer 1

doSomething<implementsParent>();

这会失败，因为它不满足类型约束。 T 不是从 Child 派生的

您是否打算声明它：

static void doSomething<T>() where T : Parent

编辑：根据您添加的要求，这将起作用。

static void doSomething<T>() where T : Parent
{
    if (typeof(T) == typeof(Parent))
    {
        T obj = orm.GetObject<T>(criteria);
    }
    else if (typeof(T) == typeof(Child))
    {
        T obj = orm.GetObject<T>(criteria);
    }
}

Answer 2

除了 T 不是从子派生这一事实之外，我认为您会想要使用

if (typeof(T).IsAssignableFrom(typeof(Parent))
  ...

否则，它只会针对完全是 Parent 类型而不是派生类型的事物触发。另外，我认为 == 对于 Type 来说没有正确重载。我认为你需要使用 .Equals()

注意：我可能已经得到了 IsAssignableFrom 向后。

Answer 3

这部分代码没有意义：

static void doSomething<T>() where T : Child
                        //   ^^^^^^^^^^^^^^^    This says that T must be a Child,
                        //                      which necessarily means it is not
                        //                      going to be a Parent
{
    if (typeof(T) == typeof(Parent))   //  <--  Therefore, this will never hit
    {

如果您希望能够传递 Parent，则绝对需要将约束定义为 T : Parent。

您说您的问题是无法将 orm.GetObject 的输出强制转换为 Child。你是对的，你不能直接将其转换 - 但你可以将其转换为Parentfirst和then到子。我认为这应该可行：

static void doSomething<T>() where T : Parent
{
    if (typeof(T) == typeof(Parent))
    {
        Parent obj = (Parent) orm.GetObject<T>(criteria);
    }
    else if (typeof(T) == typeof(Child))
    {
        Child obj = (Child) (Parent) orm.GetObject<T>(criteria);
    }
}

从编译器的角度来看，T就像类层次结构的成员，有点像这样：

                  ┌──────────┐
                  |  Parent  |
                  └─┬──────┬─┘
                    │      │
                    ↓      ↓
            ┌─────────┐  ┌───────┐
            |  Child  |  |   T   |
            └─────────┘  └───────┘

我认为这向您展示了为什么不能直接从T 到 Child，但您可以向上转换为 Parent （这总是成功的，因为 T 是 Parent），然后向下转换为 Child （这会在运行时检查它是否真的是一个Child，这当然在你的情况就会如此）。

（顺便说一句，我假设您需要使用orm.GetObject并且您不能使用orm .GetObject 如果可以，那就更简单了，但也许不能，因为 criteria 取决于 T。）