递归回调至虚方法：组合模式遍历代码重复问题求解

当然可以！这其实是组合模式中解决遍历代码重复的经典思路，而且完全不需要用到反射——把你说的“回调”逻辑抽象成Component抽象类中的虚方法就行，让Composite类只负责统一的遍历流程，具体操作交给叶子（Leaf）和组合（Composite）自己去实现。

核心思路 #

组合模式的核心是让叶子节点和组合节点对外呈现一致的接口。我们可以把每次遍历中需要执行的具体操作（也就是你说的“回调”）定义为Component中的虚方法，Composite只需要负责递归遍历所有子组件，并调用它们的这个虚方法；而Leaf则直接实现这个方法的具体逻辑。这样所有遍历相关的重复代码都会被收拢到Composite的统一遍历逻辑里，新增操作只需要添加新的虚方法即可。

代码示例（以C#为例） #

1. 定义抽象组件类（Component）

这里我们把具体操作抽象为虚方法，同时提供组合类需要的添加/移除子组件的基础方法：

public abstract class Component
{
    public string Name { get; set; }

    protected Component(string name)
    {
        Name = name;
    }

    // 这就是你所说的“回调”虚方法，不同组件实现不同逻辑
    public abstract void Process();

    // 组合类专用方法，叶子类可以抛出异常或空实现
    public virtual void Add(Component component)
    {
        throw new NotImplementedException("叶子节点无法添加子组件");
    }

    public virtual void Remove(Component component)
    {
        throw new NotImplementedException("叶子节点无法移除子组件");
    }

    protected virtual IEnumerable<Component> GetChildren()
    {
        return Enumerable.Empty<Component>();
    }
}

2. 实现叶子节点（Leaf）

叶子节点只需要专注于具体的操作逻辑，不需要处理遍历：

public class Leaf : Component
{
    public Leaf(string name) : base(name) { }

    public override void Process()
    {
        Console.WriteLine($"处理叶子节点: {Name}");
        // 这里写叶子节点的具体业务逻辑
    }
}

3. 实现组合节点（Composite）

组合节点只负责统一的遍历逻辑，调用子组件的虚方法，完全避免重复代码：

public class Composite : Component
{
    private readonly List<Component> _children = new List<Component>();

    public Composite(string name) : base(name) { }

    public override void Add(Component component)
    {
        _children.Add(component);
    }

    public override void Remove(Component component)
    {
        _children.Remove(component);
    }

    protected override IEnumerable<Component> GetChildren()
    {
        return _children.AsReadOnly();
    }

    public override void Process()
    {
        Console.WriteLine($"处理组合节点: {Name}");
        // 统一的遍历逻辑，所有操作都复用这个流程
        foreach (var child in GetChildren())
        {
            child.Process();
        }
    }
}

扩展新操作的方式 #

如果后续需要新增另一种遍历操作（比如打印节点详情），只需要在Component中添加新的虚方法，然后让Leaf和Composite分别实现即可：

// 在Component中新增虚方法
public abstract void PrintDetails(int indentLevel = 0);

// Leaf的实现
public override void PrintDetails(int indentLevel)
{
    Console.WriteLine($"{new string('-', indentLevel)} 叶子节点: {Name}");
}

// Composite的实现
public override void PrintDetails(int indentLevel)
{
    Console.WriteLine($"{new string('-', indentLevel)} 组合节点: {Name}");
    foreach (var child in GetChildren())
    {
        child.PrintDetails(indentLevel + 2);
    }
}

为什么这个方案可行？ #

• 避免代码重复：Composite类只维护一套遍历逻辑，所有需要遍历的操作都复用这个流程，不会出现重复的循环代码。
• 符合开闭原则：新增操作只需要添加新的虚方法，不需要修改已有遍历逻辑。
• 无需反射：通过多态（虚方法的重写）自动分发到对应的组件实现，完全不需要依赖反射。

内容的提问来源于stack exchange，提问作者shinzou