c# - 仅使用抽象类部分实现接口时如何满足编译器？

Question

我这里有一个名为IFish. 我想用WalkingFishCommon提供不完整实现的抽象类 () 派生它，因此派生自的类WalkingFishCommon不必实现该CanWalk属性：

interface IFish
{
    bool Swim();
    bool CanWalk { get; }
}

abstract class WalkingFishCommon : IFish
{
    bool IFish.CanWalk { get { return true; } }

    // (1) Error: must declare a body, because it is not marked
    // abstract, extern, or partial
    // bool IFish.Swim();

    // (2) Error: the modifier 'abstract' is not valid for this item
    // abstract bool IFish.Swim();

    // (3): If no declaration is provided, compiler says 
    // "WalkingFishCommon does not implement member IFish.Swim()"
    // {no declaration}

    // (4) Error: the modifier 'virtual' is not valid for this item
    // virtual bool IFish.Swim();

    // (5) Compiles, but fails to force derived class to implement Swim()
    bool IFish.Swim() { return true; }
}

我还没有发现如何让编译器满意，同时仍然实现强制从 WalkingFishCommon 派生的类实现该Swim()方法的目标。特别令人费解的是 (1) 和 (2) 之间的增量，编译器在抱怨Swim()未标记为抽象的情况下交替出现，然后在下一次呼吸中抱怨它不能标记为抽象。有趣的错误！

有什么帮助吗？

Answer 1

只需声明Swim为abstract，不要尝试对其使用显式接口声明（即 remove IFish）。

abstract class WalkingFishCommon : IFish
{
    public bool CanWalk { get { return true; } }
    public abstract bool Swim();
}

Answer 2

通常，接口是通过在类中为接口的每个成员定义一个公共成员来隐式实现的：

class MyFish : IFish
{
    public bool CanWalk { get { return ...; } }

    public bool Swim() { return ...; }
}

如果您不想为这些成员之一提供实现，您可以简单地使其抽象：

abstract class FishBase : IFish
{
    public virtual bool CanWalk { get { return true; } }

    public abstract bool Swim();
}

如果您确实需要显式实现接口，您可以创建两个成员：一个必须被派生类覆盖的抽象成员，以及一个实现接口并将调用转发给第一个成员的成员：

abstract class FishBase : IFish
{
    public virtual bool CanWalk { get { return true; } }

    protected abstract bool Swim();

    bool IFish.Swim() { return Swim(); }
}

Answer 3

如果你真的不需要显式地实现接口，你可以简单地这样做：

abstract class WalkingFishCommon : IFish {
    public abstract bool CanWalk { get; }
    public abstract bool Swim();

}

如果显式实现很重要，可以通过引入受保护的抽象方法来解决问题：

abstract class WalkingFishCommon : IFish {
    bool IFish.CanWalk { get { return CanWalkCore; } }
    bool IFish.Swim() { return SwimCore(); }

    protected abstract bool CanWalkCore { get; }
    protected abstract bool SwimCore();

}

Answer 4

不完全是一个解决方案，但也许你可以做类似的事情

interface IWalkingFish
{
    bool CanWalk { get; }
}

interface ISwimmingFish
{
    bool Swim();
}

interface IFish : ISwimmingFish, IWalkingFish
{ }

abstract class WalkingFishCommon : IWalkingFish
{
    bool IWalkingFish.CanWalk { get { return true; } }
}

然后，您可以为抽象类和具体类使用不同的接口。