这是我的接口:
public interface MyInterface {
bool Foo();
}
这是我的抽象类:
public abstract class MyAbstractClass : MyInterface {
abstract bool MyInterface.Foo();
}
这是编译错误信息:"The modifier 'abstract' is not valid for this item."
我应该如何明确实现一个抽象方法并使其为抽象的?
基本上你不能这样做。至少不能直接这样做。你不能覆盖实现接口的方法,而你需要覆盖抽象方法。最接近的解决方案可能是:
bool MyInterface.Foo() {
return FooImpl();
}
protected abstract bool FooImpl();
那仍然显式实现了接口并迫使派生类实际提供实现。这些是您试图实现的方面吗?
你需要使用隐式实现接口成员而不是显式实现:
public abstract class MyAbstractClass : MyInterface
{
public abstract bool Foo();
}
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#不允许抽象类具有不完整的接口实现,这真是可惜。)
优点是您可以节省一个calli指令,从而避免CPU流水线停顿。但是,由于接口调用,该方法无法进行内联,因此影响相对较小。因此,我建议仅在对性能至关重要的情况下使用它。
我不确定你为什么需要这样做。为什么不让抽象类的具体实现实现接口成员呢?其实这是一样的。
即使您不使用它们,也要将在抽象类中实现的所有接口方法抽象化。
这种情况需要您实现具有接口的2个或多个抽象类层次结构。
我也尝试在C#中实现层次结构。我需要一个接口,但我想要一个抽象类,因为大多数属性对于接口来说是相同的。为此,我必须创建一个单独的带有实现的抽象类,然后我的具体类,或者在我的情况下是另一个抽象类,将继承接口和抽象类。
我认为这第一个例子出于许多原因都不是一个好的例子,但我必须拥有它,因为编译器不允许FooBar实现Foo,然后再有另一个抽象类继承FooBar。所以我有一个带有抽象方法bar()的抽象类,和带有bar()方法的接口。
public interface Foo {
bool bar();
//other stuffs
}
public abstract class FooBar {
public abstract bool bar();
//Other stuffs
}
public abstract class FooBarAbstraction: FooBar, Foo {
//other stuffs
//Don't supply the interface and abstract here
}
public class FooBarConcrete: FooBarAbstraction {
public override bool bar() {
return true;
}
//other stuffs
}
这是我的第一次尝试,然后我变得好奇并开始思考。我找到了这个解决方案。更好的解决方案。
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
}
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();
我能够做到这一点
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();
}
}