OOP设计：具有相同基础类的具有不同操作的具体类

Question

我想知道是否可以用C＃编写以下代码：

AbstractClass a = new ConcreteClass1();
a.Operations.Method1();

AbstractClass b = new ConcreteClass2();
b.Operations.Method2();

其中Method1（）是ConcreteClass1实例的独占，而Method2（）是ConcreteClass2（）实例的独占。 结果，a.Operations.Method2（）和b.Operations.Method1（）无效。

Answer 1

这是不可能的设计- a和b具有相同的类型，编译器会这样对待他们。 使其起作用的唯一方法是使用运行时异常。

使用抽象类或接口的概念与您尝试执行的操作存在冲突。 听起来ConcreteClass1和ConcreteClass2的用途不同，还是应该使用相同的抽象基类？

我不知道您到底想做什么-因此，我将提供一些选择：

使用接口来显示特定的类实现特定的操作：

interface IOperation1
{
    void Operation1();
}

interface IOperation2
{
    void Operation2();
}

然后根据您要实现的目标引用接口。

如果Method1和Method2应该在同一时间被调用，考虑设计，其中AbstractClass声明要调用的方法，以及具体的类基础上完成不同的操作：

abstract class AbstractClass
{
   ...
   abstract void DoSomeOperation();
}

class ConcreteClass1 
{
   override void DoSomeOperation() 
   {
      this.Operations.Method1();
   }
}

class ConcreteClass2 
{
   override void DoSomeOperation() 
   {
      this.Operations.Method2();
   }
}

Answer 2

ConcreteClass1和ConcreteClass2可以使用一些不同的方法，但是共享一些都从AbstractClass继承的功能。 （如果将它们强制转换为它们的基本类型，则只能调用它们从基本类型继承的通用方法。）

这听起来像之间的具体类是否使用差分Method1或Method2是一个内部细节应的类的内部进行处理。 该类应该知道它需要调用什么方法。 实际上，该类别的使用者是否甚至需要知道它取决于Operations ？ 可能不是。 使用者应该只在类上调用一个方法，然后该类是否使用Operations.Method1 ， Operations.Method2甚至完全依赖于Operations是内部实现细节。

也许您想要的是这样的：

public abstract class AbstractClass
{
    public abstract void DoSomething();
}

public class Operations
{
    public void Method1()
    {
        //Does something
    }

    public void Method2()
    {
        //Apparently does something comopletely different
    }
}

public class ConcreteClass1 : AbstractClass
{
    private Operations _operations;

    public override void DoSomething()
    {
        _operations.Method1();
    }
}

public class ConcreteClass2 : AbstractClass
{
    private Operations _operations;

    public override void DoSomething()
    {
        _operations.Method2();
    }
}

仅当要求 每个派生类都将使用它时 ， Operations才应该在基类中。 （这不会发生太多。如果所有派生类都具有相同的行为，为什么它不在基类中？）如果是这种情况，则可以将其隐藏在基类中，如下所示：

public abstract class AbstractClass
{
    private Operations _operations;

    protected Operations Operations { get { return _operations; } }
    public abstract void DoSomething();
}

这样，它就暴露给派生类，而对其他所有事物都隐藏了。