C＃在基类/抽象类中的最佳部分接口实现

Question

.net不允许在基类中实现部分接口。作为一种缓解措施，我已经选择了3种备选解决方案。请帮助我确定哪一个更适用于重构，编译/运行时错误，可读性。 但首先有几条评论。

• 当然，您可能总是将对象投射到IFoo并在没有任何编译器警告的情况下调用任何方法。但这不合逻辑，你不会那样做。这个构造不会因重构而发生。
• 我想要最大的分离度。直接类合同（公共方法和属性）应该与接口实现分开。我使用很多接口来分离对象的交互。

我比较：

1. BaseClass1/MyClass1的：
   • CON：有在BaseClass1创建虚拟抽象的IFoo的每个未实现的方法。
   • con：其他方法包装 - 运行时对生产力的影响很小。
2. BaseClass2/MyClass2：
   • CON：没有编译器警告，如果在MyClass2没有实现方法2的。运行时异常。用单元测试覆盖较差的重构可能会破坏代码的稳定性。
   • con：必须放置额外的过时构造来防止子类中的直接方法调用。
   • con：Method2对于BaseClass1是公开的，所以它现在是类合同的一部分。必须放置“过时”构造以防止直接呼叫，而不是通过IFoo。
3. BaseClass3/MyClass3：
   • 亲：（相较于＃2）。更可读。你会发现MyClass2.Method2是IFoo的实现，而不仅仅是一些重载方法。

public interface IFoo 
{ 
    void Method1(); 
    void Method2(); 
} 

public abstract class BaseClass1 : IFoo 
{ 
    void IFoo.Method1() 
    { 
     //some implementation 
    } 

    void IFoo.Method2() 
    { 
     IFooMethod2(); 
    } 

    protected abstract void IFooMethod2(); 
} 

public class MyClass1 : BaseClass1 
{ 
    [Obsolete("Prohibited direct call from child classes. only inteface implementation")] 
    protected override void IFooMethod2() 
    { 
     //some implementation 
    } 
} 

public abstract class BaseClass2 : IFoo 
{ 
    void IFoo.Method1() 
    { 
     //some implementation 
    } 

    [Obsolete("Prohibited direct call from child classes. only inteface implementation")] 
    public virtual void Method2() 
    { 
     throw new NotSupportedException(); 
    } 
} 

public abstract class MyClass2 : BaseClass2 
{ 
    public override void Method2() 
    { 
     //some implementation 
    } 
} 

public abstract class BaseClass3 : IFoo 
{ 
    void IFoo.Method1() 
    { 
     //some implementation 
    } 

    void IFoo.Method2() 
    { 
     throw new NotSupportedException(); 
    } 
} 

public abstract class MyClass3 : BaseClass3, IFoo 
{ 
    void IFoo.Method2() 
    { 
     //some implementation 
    } 
} 

Answer 1

好吧，你可以试试下面的BaseClass是抽象：

public interface IFoo 
{ 
    void Method1(); 

    void Method2(); 
} 

public abstract class BaseClass : IFoo 
{ 
    public void Method1() 
    { 
     // Common stuff for all BaseClassX classes 
    } 

    // Abstract method: it ensures IFoo is fully implemented 
    // by all classes that inherit from BaseClass, but doesn't provide 
    // any implementation right here. 
    public abstract void Method2(); 
} 

public class MyClass1 : BaseClass 
{ 
    public override void Method2() 
    { 
     // Specific stuff for MyClass1 
     Console.WriteLine("Class1"); 
    } 
} 

public class MyClass2 : BaseClass 
{ 
    public override void Method2() 
    { 
     // Specific stuff for MyClass2 
     Console.WriteLine("Class2"); 
    } 
} 

private static void Main(string[] args) 
{ 
    IFoo test1 = new MyClass1(); 
    IFoo test2 = new MyClass2(); 

    test1.Method2(); 
    test2.Method2(); 

    Console.ReadKey(); 
} 

Answer 2

这是非常糟糕的设计是没有按类没有一个明确的定义d合同。这是极端的，因为你首先说一个班级有能力做某事。你明确地强调类可以做的东西，但后来在你说的那个代码中，拧紧它，这个类可以在没有实现的情况下生存。编译器非常明智地要求您执行合同，但由您决定。

下面是一些常见的解决方案

不好解决

• 抛出一个异常（NonImplementedException或NotSupportedException异常，见sample）
• 声明为过时的（设计它从一开始就很好）

更好解决方案

• 显式接口实现，但你仍然实现它（只是一种隐藏）

最好的解决方案

• 使用接口隔离（拆你的脂肪接口转换成更薄和更易于管理的）

Answer 3

我建议具有抽象基类实现接口调用protected abstract方式方法，如在第一个例子中，除了一些派生类可能无法实现方法（继“抛开一切到IList但没有所有的方法实际上工作“模式）;那些可能是protected virtual存根扔NotSupportedException。

注意，它是由子类是否对接口的任何特定成员公开为名称相同的公共成员（可调用相应的抽象成员）。

在VB.net中的正确模式将类似MustOverride Sub IFoo_Method1() Implements IFoo.Method1，这将避免额外的函数调用开销，但C＃没有提供任何实现与受保护成员接口的方法。对于可能必须在子类中重写的任何方法使用显式接口实现有点难以实现，因为孩子的接口的重新实现不可能链接到父实现。

Answer 4

我喜欢这个版本，基类不能被实例化，因为它的抽象，派生类必须列出的IFoo在其声明中，否则它将不会被实现接口，然后是实施其余全权负责的界面。 一个缺点我能看到的是你不能明确地实现在基类的接口方法（即没有的IFoo：方法），但除此之外，这是一个相当低开销的版本。

public interface IFoo 
{ 
    void Method1(); 
    void Method2(); 
} 

public abstract class BaseClass1 
{ 
    public void Method1() 
    { 
     //some implementation 
    } 
} 

public class MyClass1 : BaseClass1, IFoo 
{ 
    public void Method2() 
    { 
     //some implementation 
    } 
}