Question

这是我的界面：

public interface MyInterface {
    bool Foo();
}

这是我的抽象类：

public abstract class MyAbstractClass : MyInterface {
    abstract bool MyInterface.Foo();
}

这是编译器错误： “修饰符'abstract'对此项无效。

我应该如何继续使用抽象方法显式实现抽象？

Answer 1

基本上，你不能。反正不是直接的。您不能覆盖显式实现接口的方法，并且有来覆盖抽象方法。你最接近的将是：

bool MyInterface.Foo() {
    return FooImpl();
}

protected abstract bool FooImpl();

仍然显式实现接口和强制派生类实际提供实现。这些是你想要实现的方面吗？

Answer 2

您必须使用接口成员的隐式实现，而不是显式实现：

public abstract class MyAbstractClass : MyInterface
{
    public abstract bool Foo();
}

Answer 3

我不确定你为什么需要。为什么不让抽象类的具体实现从接口实现成员？这真是一回事。

Answer 4

abstract method没有实现，因此无法用于显式实现接口方法。

Answer 5

我能够做到这一点

public interface SampleInterface
{
    void member1();
    void member2();
    void member3();
}

public abstract class Client2 : SampleInterface.SampleInterface
{
    public void member1()
    {
        throw new NotImplementedException();
    }

    public abstract void member2();


    public void member3()
    {
        throw new NotImplementedException();
    }
}

public class Client3 : Client2
{
    public Client3()
    {

    }

    public override void member2()
    {
        throw new NotImplementedException();
    }
}

Answer 6

除了Jon的解释：这是一种绕过问题而不是直接解决问题的方法，只会在某些情况下起作用，但也许有人会从这个想法中受益。

如果您计划将所有（或至少大多数）接口方法调用传递给派生类，您可以通过以下方式执行此操作：

public interface MyInterface 
{
    bool Foo();
}

public abstract class MyAbstractClass
{
    public abstract MyInterface AsMyInterface();
}

public class MyDerivedClass : MyInterface
{
    public override MyInterface AsMyInterface()
    {
        return this;
    }

    public bool Foo()
    {
        return false;
    }
}

...

MyAbstractClass c = new MyDerivedClass();
MyInterface i = c.AsMyInterface();
bool b = i.Foo();

Answer 7

摘要抽象类中实现的所有接口方法，即使您不使用它们。

这种特殊情况要求您使用接口实现2个或更多抽象类的层次结构。

我也试图在C＃中实现层次结构。我需要一个接口，但我想要一个Abstract类，因为接口的大多数属性是相同的。要做到这一点，我必须使用实现创建一个单独的Abstract类，然后我的Concrete类，或者在我的情况下，另一个抽象类将继承Interface和Abstract Class。

我不认为第一个是一个很好的例子有很多原因，但我不得不拥有它，因为编译器不允许FooBar实现Foo，然后有另一个抽象类来继承FooBar。所以我有一个带抽象方法bar（）的抽象类，以及带bar（）方法的接口。

public interface Foo { 
    bool bar();
    bool buzz();
    //other stuffs
}


public abstract class FooBar : Foo{
    public abstract bool bar();
    public abstract bool buzz();
    //Other stuffs
}

public abstract class FooBarAbstraction: FooBar {
     //other stuffs
     //Don't supply the interface and abstract here
     // override everything else
     public override bool buzz() {
         return false;
     }
}

public class FooBarConcrete: FooBarAbstraction {
    public override bool bar() {
        return true;
    }
   //other stuffs
}

这是我的第一次尝试，然后我好奇并开始考虑它。我遇到了这个解决方案。更好的解决方案。

def testHomePageCanSaveAPostRequest(self):
    request = HttpRequest()
    request.method = 'POST'
    request.POST['itemText'] = 'A new list item'

    response = homePage(request)
    if response:
        response = response.content.decode('UTF-8')

    self.assertIn('A new list item', response)

    expectedHTML = render(request, 'lists/home.html', {'itemText':'A new list item'})
    if expectedHTML:
        expectedHTML = expectedHTML.content.decode('UTF-8')

    print(response)
    print(expectedHTML)
    if response==expectedHTML:
        print('Same')

    self.assertIn('A new list item', expectedHTML)

    self.assertEqual(response, expectedHTML)

Answer 8

事实上，除了使用仍然保持实现私有的抽象辅助方法之外，还有另一种选择：

public abstract class MyAbstractClass : MyInterface
{
  bool MyInterface.Foo() // must be overridden
  { throw NotImplementedException(); // never called
  }
}

public class MyDerivedClass : MyAbstractClass, MyInterface
{
  bool MyInterface.Foo() // overrides MyInterface.Foo
  { // Place your implementation here
  }
}

如果接口有许多方法，并且在派生类中只重新定义了其中一些方法，则此模式也将起作用。当然，您也可以使用它来覆盖私有接口实现。

主要缺点是Foo不能在MyAbstractClass中声明为抽象，因此编译器无法确保实际覆盖该方法。（遗憾的是抽象类在C＃中可能没有不完整的接口实现。）

优点是您保存一条可能导致CPU管道停顿的calli指令。但是，影响非常小，因为由于接口调用，无论如何都无法内联该方法。因此，我建议仅针对性能危急情况。

用抽象方法显式实现接口

8 个答案: