2

我有 3 个接口和 2 个方法，每个方法都做同样的工作。

Interface A
{
   Void M1()
   Void M2()
}

Interface B
{
   Void M1()
   Void M2()
}

Interface C
{
   Void M1()
   Void M2()
}

现在，有 3 个类实现了这些接口中的每一个。

Public Class A1:A
{
  Public void M1()
  {

  }
  Public void M2()
  {

  }
}

Public Class B1:B
{
  Public void M1()
  {

  }
  Public void M2()
  {

  }
}

Public Class C1:C
{
  Public void M1()
  {

  }
  Public void M2()
  {

  }
}

M1 和 M2 的功能在 3 个类中完全相同。接口是库的一部分，我不能更改接口，也不能声明新接口。

我想重构此代码，以便可以删除此重复项。我想创建一个包含此功能的公共类，然后从这些类中的每一个调用公共类。

请建议。

4

5 回答 5

2

听起来您应该声明自己的接口，然后创建一个适配器 - 或者可能是多个适配器。例如：

public interface IUnified
{
    void M1();
    void M2();
}

public class UnifiedAdapter : IUnified
{
    private Action m1;
    private Action m2;

    public UnifiedAdapter(A a)
    {
        m1 = () => a.M1();
        m2 = () => a.M2();
    }

    public UnifiedAdapter(B b)
    {
        m1 = () => b.M1();
        m2 = () => b.M2();
    }

    public UnifiedAdapter(C c)
    {
        m1 = () => c.M1();
        m2 = () => c.M2();
    }

    public M1()
    {
        m1();
    }

    public M2()
    {
        m2();
    }
}

（这使用委托来避免创建多个适配器类。最好的方法取决于您的具体情况。）

于 2013-01-18T10:00:42.473 回答
0

如果您只想避免重复这些方法的实现，那么您的初始方法是正确的。

public class HelperClass
{
   public static void M1()
   {
      // implementation code
   }
   public static void M2()
   {
      // implementation code
   }
}

public class A1:A
{
   public void M1()
   {
       HelperClass.M1();
   }
   public void M2()
   {
       HelperClass.M2();
   }
}

public class B1:B
{
   public void M1()
   {
       HelperClass.M1();
   }
   public void M2()
   {
       HelperClass.M2();
   }
}

public class C1:C
{
   public void M1()
   {
       HelperClass.M1();
   }
   public void M2()
   {
       HelperClass.M2();
   }
}

即使接口 A、B 和 C 具有相同的方法，它们也可能具有不同的语义，并且将它们作为单独的接口可能是有意义的。也就是说，让一个类实现 A，可能意味着与实现 B 不同的东西，即使它们的方法具有相同的签名。

添加额外的接口或公共基类是多余的，并增加了不必要的耦合。正如我之前所说，如果您只需要避免重复方法的实现，辅助类是最简单和最干净的解决方案。

于 2013-01-18T12:33:52.757 回答
0 
public class BaseClass : A, B, C
{
   public void M1()
   {    
   }

   public void M2()
   {    
   }
}

然后从 BaseClass 继承：

public class A1 : BaseClass
{
}

public class B1 : BaseClass
{
}

public class C1 : BaseClass
{
}

A1仍然会实现接口A。B1将实现接口B。与 相同C1。因此，您现有的所有代码都将继续工作：

A a = new A1();
a.M1();
于 2013-01-18T10:02:30.757 回答
0 
public abstract class XX : X
{
    public void M1()

    {

    }

    public void M2()
    {

    }
}

public interface X : A, B, C
{
}
于 2013-01-18T10:03:38.103 回答
0

鉴于奇怪的限制（如果可以的话，我真的建议尝试更改接口）我认为这是你能做的最好的：

public class Base : A, B, C {
  public void M1(){}
  public void M2(){}
}

现在从 A1、B1 和 C1 中的 Base 继承。

但是，如果 aA不能或不应该也是 a，B那么这种模式将不起作用。

因此，您确实必须选择下一个最好的东西 - 具有通用功能的通用基础：

public class Base {
  protected void M1Impl() { /* put your common implementation in here */ }
  protected void M2Impl() { /* put your common implementation in here */ }
}

正如评论所说 - 将重复的M1和M2代码放在M1ImplandM2Impl方法中。

现在您可以将此基础用于A,B和C实现：

//common base for any implementation of A
//repeat for B and C
public class A1Base : Base, A
{ 
  public void M1() { M1Impl(); }
  public void M2() { M2Impl(); }      
}

public class A1 : A1Base { }

我在这里工作的基础是，您可能有许多AorB或其他的实现，因此您希望每个实现都有一个共同的起点。如果不是这种情况，那么您可以取消A1Base并简单地调用它A1。

于 2013-01-18T10:04:10.460 回答