Question

假设我们有一个接口层次结构：IBaseThing<T>和IChildThing:IBase<ChildThing>。还有两个类：

internal abstract class Base<T>
{
    public abstract IBaseThing<T> Thing {get;}
}

和

internal class Concrete:Base<ChildThing>
{
    public override IChildThing Thing
    {
        get
        {
            return GetChildThing();
        }
     }
}

将会发生的事情如下：

'Concrete'不实现继承的抽象成员 'Base.get'

我想跳过整个(IChildThing)this.Thing课程的Concrete。我应该做什么？

Answer 1

试试这个解决方案：

public interface IBaseThing {}

public interface IChildThing : IBaseThing {}

internal abstract class Base<T> where T : IBaseThing
{
    public abstract T Thing {get;}
}

internal class Concrete:Base<IChildThing>
{
    public override IChildThing Thing
    {
        get
        {
            return GetChildThing();
        }
     }

     public IChildThing GetChildThing()
     {  
        // Your impelementation here...
        return null;
     }
}

Answer 2

你做不到。类型系统正在反对您尝试更改覆盖类中的方法类型。 IChildThing可能来自IBaseThing，但它不是一回事。例如，您可以稍后再向IChildThing添加一些方法。然后，一个类（Concrete）将承诺返回的对象具有与基类不同的签名 - 这是类型错误。

如果在某些情况下需要引用IChildThing，请执行以下操作：

internal class Concrete : Base<ChildThing>
{
    public override IBaseThing<ChildThing> Thing
    {
        get { return ChildThing; }
    }

    public IChildThing ChildThing { get; set; }
}

如果你拥有的只是一个Base，那么你就无法安全地进入IChildThing。这就是像这样的强类型系统的本质。如果这是一个问题，那么如果你给出了一个更具体的例子，我可能会建议如何重组以避免这个问题。

接口继承和抽象方法覆盖

2 个答案: