显式运算符重载+继承

Question

我一直在思考一种解决问题的方法，但我不确定它是否会奏效。

假设我们有一个名为A的基类和3个子类B、C和D。

        A
        ^
-----------------
|       |       |
B       C       D

我们也有三个类X，Y和Z。

在我的系统对象中，类型B、C、D作为类型A传递，通常我必须将类型B、C、D的对象转换为对象X、Y或Z(这不是强制转换，我手动转换它们，因为它们是完全不同的)。

因此，要将对象类型A转换为X、Y或Z类型，我需要首先检查子类型，然后根据子类型使用对A对象的某些操作的结果初始化X、Y或Z对象。

我想过将显式的强制转换操作从A重载到X、Y或Z，就像我转换它们时所做的一样，但后来我想……是否可以使用polimorfism并以某种方式重载来自B、C和D的强制转换，以便在添加A的新子类型时不需要更改A的强制转换代码？(只需将显式强制转换重载添加到新的子类型中)

我希望我已经正确地解释了我自己，如果有什么令人困惑的地方，很抱歉。

注意:我将为X，Y，Z添加一个强制转换重载

Answer 1

您可以让类型A的强制转换操作符调用虚拟(或抽象？)方法，并为A的每个子类覆盖该方法。但是，对于这个解决方案，X、Y和Z应该派生自一个共同的基类，因此强制转换运算符可以将该基类作为结果类型。

public abstract class A
{
    protected abstract W ConvertToW();

    public static explicit operator W(A a)
    {
        return a.ConvertToW();
    }
}

在本例中，W是X、Y和Z的基类。

Answer 2

假设X、Y和Z派生自公共类型T，则在A中声明一个抽象转换方法

public abstract class A
{
    public abstract T Convert();
}

在B中重写它以返回X，在C中重写以返回Y，在D中重写以返回Z。这样，每个类型都负责返回其自己的转换类型，并且在添加新类型时不需要在A中进行任何更改。

Answer 3

abstract class A
{
    public abstract object Convert();
}
class B : A
{
    public override object Convert()
    {
        return ConvertToX();
    }
    public X ConvertToX()
    {
        return new X();
    }
}
void SomeMethod()
{
    A o = new B();
    var result = (X)o.Convert();
}

这让您在知道类为B (通过ConvertToX，因为X Convert()不能覆盖object Convert())时获得强类型的结果，并在只知道它是A的情况下获得object。由于显式转换只能基于您正在使用的变量的静态类型进行，因此没有一个真正的好方法可以像您所要求的那样使用强制转换来实现这一点。

(@svick指出了我之前代码中的一个主要缺陷，如下所示，如果你只知道对象是一个A，而不是一个A<T>，你就不能很容易地对它做任何事情。我会把它放在这里，以防您有任何用处：)

interface IConvertible<out T>
{
    T Convert();
}
abstract class A
{
}
abstract class A<T> : A, IConvertible<T>
{
    public abstract T Convert();
    public static explicit operator T(A<T> a)
    {
        return a.Convert();
    }
}
class B : A<X>
{
    public override X Convert()
    {
        // TODO implement this
    }
}

如果你有一个可以转换成多个类型的类型，你可以这样做：

class B : A<X>, IConvertible<Y>
{
    public override X Convert()
    {
        throw new NotImplementedException();
    }
    Y IConvertible<Y>.Convert()
    {
        throw new NotImplementedException();
    }
}

或者：

class B : A, IConvertible<X>, IConvertible<Y>
{
    X IConvertible<X>.Convert()
    {
        throw new NotImplementedException();
    }
    Y IConvertible<Y>.Convert()
    {
        throw new NotImplementedException();
    }
}