Question

我有4个基类：

class A { virtual SomeMethod () { <code> } }
class A<T> { virtual SomeMethod () { <code> } }

class B { virtual SomeMethod () { <code> } }
class B<T2> { virtual SomeMethod () { <code> } }

现在，我有4个实现（每个实现都是从相应的基类型派生的）。

class Aa : A { override SomeMethod () { <code> } }
class Aa<Tt> : A<T> { override SomeMethod () { <code> } }

class Bb : b { override SomeMethod () { <code> } }
class Bb<Tt2> : B<T2> { override SomeMethod () { <code> } }

现在，我需要添加SomeMethod实现（它应该是对基类中的实现的覆盖）。所有提到的派生类的SAME ONE。

什么是最佳解决方案？（我会在问题解决后立即分享我的所有想法。因为如果我把我的实施放在这里，讨论很可能是我的方向，但我不确定我是否正确。）

感谢您的好主意!!

Answer 1

所以你想要为一些4个类实现一个实现，为其他4个类实现不同的实现？也许Strategy pattern可行。

interface ISomeMethodStrategy {
    string SomeMethod(string a, string b);
}

class DefaultStrategy : ISomeMethodStrategy {
    public string SomeMethod(string a, string b) { return a + b; }
    public static ISomeMethodStrategy Instance = new DefaultStrategy();
}
class DifferentStrategy : ISomeMethodStrategy {
    public string SomeMethod(string a, string b) { return b + a; }
    public static ISomeMethodStrategy Instance = new DifferentStrategy();
}

class A {
    private ISomeMethodStrategy strategy;
    private string a, b, c;
    public A() : this(DefaultStrategy.Instance) {}
    protected A(ISomeMethodStrategy strategy){
        this.strategy = strategy;
    }
    public void SomeMethod() {
        a = strategy.SomeMethod(b, c);
    }
}

class Aa : A {
    public Aa() : base(DifferentStrategy.Instance) {}
}

我已经在这里使用界面实现了模式，但您可以对代理执行相同的操作。

Answer 2

A）。如果你确实发布了你的实现，无论你认为它会歪曲什么

，那会更好

B）。拥有class A和通用形式class A<T>的概念似乎真的外星人。这就像你的泛型类对一个特定的情况有一个排除，这意味着它比其他泛型更不通用，即很奇怪。

C）。为什么你不只是让所有4个基类都继承自更高级别的X，如果你的意思是在每个基础上都有相同的方法，或者如果你只是意味着他们实现这个常用方法，那么从接口开始。似乎太明显了，我错过了你的问题吗？

Answer 3

接口和组合而不是继承怎么样？

例如，您创建一个新界面

interface myinterface
{
   void doSomethingCool();
}

而不是实现它的新类

class interfaceImpl: myinterface
{
    public void doSomethingCool()
    {
         ... some code
    }
}

而不是

class A : myinterface
{
  private interfaceImpl interf = MyInterfaceFactory.Build(args);

  public void doSomethingCool()
  {
      interf.doSomethingCool();
  }
}

所以你可以在A，B类和所有派生类中拥有相同的行为，你也可以覆盖它。

HTH

Answer 4

我假设您希望在所有实现之间拥有一个共享（和可覆盖）的方法。非泛型类假定一个默认类型，比如int。

因此，您可以创建一个始发基类。

public class Origin {
   public virtual void SomeSharedOverrideMethod(int data) { }
}

class A : Origin {

   public void MethodForAImpl() {
       base.SomeSharedOverrideMethod(23);
   }
}

class A<T> : Origin {

   public void MethodForGenericAImpl() {
       base.SomeSharedOverrideMethod(45);
   }
}

class B : Origin
class B<T> : Origin

这是你需要的吗？

Answer 5

问题是如何在C＃中进行混音。

你可以使用大锤并采用LinFu之类的东西;还有其他方法涉及打开基本定义以添加额外的通用参数（混合对象）。它们都涉及到在语言设计中进行深思熟虑的选择。

棘手的建筑问题。 4基类需要一点可扩展性

5 个答案: