调用父方法时调用子方法

Question

我有一个 class 它有一个方法：

public class A{
    public virtual void doChanges (String message, object[] args){
    }
}

一些 classes 在 'A' 中使用 'doChange' 方法：

public class MethodClaller{
    A a = new A();
    public void caller(){
        a.doChanges ("Test",null);
    }
}

并且 ALL 子 classes 应该覆盖 doChanges:

public class B:A{
    public override void doChanges(String message, object[] args){
    }
}

问题是：我想在几个程序中使用 Class A 和 Class MethodCaller组件）并且在每个程序中，方法 doChange 应该自动调用 A 的所有子项，只要 doChange要求 A。所以像这样的代码：

new MethodCaller.call();

应该在 B.

的所有实例中调用 doChanges

听起来像是事件处理。但我不知道该怎么做。 A 和 B 与解决方案中的父子关系是否无关紧要。我只是觉得这是正确的结构。

Answer 1

您正在按顺序使用继承。

而不是 B 从 A 继承（这只是两个类之间的静态依赖）你应该注册实例 B 的实例 A 可以委托。查找delegation pattern来理解这句话。

这样做是概念上的第一步，但稍后你会可能（没人能肯定地说）最终得到更大的东西，即Composite Pattern.

要在组合中自动注册实例，您将使用创建 Factory Pattern。

它将是这样的：

A 将允许它的实例是复合的；
B 将是一个可以附加到 A;

您将在 B 上使用工厂方法来实例化 B 的元素，这需要 A:

的实例

A a; // get the instance "a" from somewhere
B.Create(a); // will create an instance of B and attach it to a

要强制使用此用法，您将 private 照常设置 B 的构造函数（请参阅工厂模式）。

Create() 将是这样的：

private B() // prevent direct instance creation
{
    // ...
}

public static void Create(A a)
{
    B b;

    b = new B();
    a.Register(b);
}

所以你确定 所有 B 都附加到一个 A（类似于你的要求 所有 B 必须扩展 A ).

A 中的 Register() 将是：

private List<B> _bs = new List<B>();

public void Register(B b)
{
    _bs.Add(b);
}

A 中的 Do() 将是：

public void Do(object args)
{
    // pre-procedure of A

    foreach (B b in _bs)
    {
        b.Do(args);
    }

    // post-procedure of A
}

现在要确保 B 实现 Do() 方法而不使用类之间的静态依赖关系通过定义组件接口利用复合模式：

interface AComponent
{
    void Do(object args);
}

从中导出 B:

class B implements AComponent
{
    ...

最后引用 A 的接口（而不是 B）：

private List<AComponent> _components = new List<AComponent>();

public void Register(AComponent component)
{
    _components.Add(component);
}

public void Do(object args)
{
    // pre-procedure of A

    foreach (AComponent component in _components)
    {
        component.Do(args);
    }

    // post-procedure of A
}

最后一步是在 create 方法中使用复合接口将 B 与 A 解耦：

interface AComposite
{
    void Register(AComponent component);
}

从中得出A：

class A implements AComposite
{
    ...

在create方法中使用接口：

public static void Create(AComposite composite)
{
    composite.Register(new B());
}

现在 A 和 B 松耦合，但是 B 的实例必须在 A 的实例上注册，这样当 Do() 触发时， B 的所有实例也会触发它们的 Do() 方法。

作为一个好处，您可以拥有与 B 完全不同的 AComponent 的实现（根据继承），并且仍然让它们触发它们的 Do() 方法。您甚至可以混淆 AComponent 的不同实现的实例，就像多态允许通过虚拟方法一样。

你觉得这有意义吗？

调用父方法时调用子方法

call child method when parent method called

c#

methods

parent-child