复合设计模式：如何通过相同的接口来操作单个对象以及由这些对象组成的群体

void demonstrateNesting() {
  
  final seyi = SingleUser(100000, List.generate(12, _) => 20000);
  final ronke = SingleUser(5000, List.generate(12, _) => 50000);
  final ini = SingleUser(20000, List.generate(12, _) => 20000);
  final tiwa = SingleUser(10000, List.generate(12, _) => 10000);

  final child1 = SingleUser(100000, List.generate(12,_) => 20000);
  final child2 = SingleUser(100000, List.generate(12, _) => 20000);
  final child3 = SingleUser(100000, List.generate(12, _) => 20000);

  // 家庭群体
  final fatunmoles = UserGroup('Fatunmoles');
  fatunmoles
    ..add(seyi)
    ..add(ronke)
    ..add(ini)
    ..add(tiwa);

  final unknownFamily = UserGroup('UnknownFamily');
  unknownFamily
    ..add(child1)
    ..add(child2)
    ..add(child3);

  // 一个包含其他组合体的复合体
  // 这两个家庭群体被视为一个整体来处理
  final allFamilies = UserGroup('AllFamilies');
  allFamilies
    ..add(fatunmoles)    
    ..add(unknownFamily); 

  // 同一的接口，现在可以涵盖这两个家庭群体中的所有7个人
  print('两个家庭群体合并后的结果:');
  print('总税款金额: ${allFamilies.getTaxAmount()}'); 
  print('总折扣金额: ${allFamilies.getTaxDiscount()}'); 
  print('今年的累计税款: ${allFamilies.getTotalTaxYTD()}');
}

allFamilies.getTaxAmount()会遍历整个结构：它首先向fatunmoles请求其总税额，而fatunmoles则会再询问它的四个成员各自的税额；接着它还会向unknownFamily请求其总税额，而unknownFamily同样会询问它的三个成员各自的税额。整个过程中只进行了一次方法调用，但涉及了七个人。调用者并不了解这个结构的层次结构，也不知道每一层中包含多少个成员。

正是在这里，这种设计模式展现出了它真正的价值。你可以构建一个由部门、团队和个人组成的组织结构，所有这些组件都实现了相同的TaxManager接口，然后你就可以对这个整个组织调用getTaxAmount()方法来获取其中每个人的税额总和。或者也可以只对某个具体的部门或个人调用这个方法。无论在哪种情况下，接口的使用方式都是完全相同的。

C#中的组合模式

在C#中运用同样的设计模式，可以清楚地看到：这其实是一种普遍适用的结构原则。下面是一个为企业的工资发放系统设计的税务管理系统示例，该系统就是用C#实现的。

组件

public interface ITaxManager
{
    decimal GetTaxAmount();
    decimal GetTaxDiscount();
    decimal GetTotalTaxYTD();
}

叶子节点

public class Employee : ITaxManager
{
    private readonly string _name;
    private readonly decimal _taxAmount;
    private readonly List〈decimal〉 _yearlyTaxes;

    public Employee(string name, decimal taxAmount, List〈decimal〉 yearlyTaxes)
    {
        _name = name;
        _taxAmount = taxAmount;
        _yearlyTaxes = yearlyTaxes;
    }

    public decimal GetTaxAmount() => _taxAmount;

    public decimal GetTaxDiscount()
    {
        return _taxAmount % 2 == 0 ? _taxAmount : _taxAmount / 2;
    }

    public decimal GetTotalTaxYTD()
    {
        return _yearlyTaxes.Sum();
    }
}

组合对象

public class Department : ITaxManager
{
    private readonly string _name;
    private readonly List〈ITaxManager〉 _members = new();

    public Department(string name)
    {
        _name = name;
    }

    public void Add(ITaxManager member) => _members.Add(member);
    public void Remove(ITaxManager member) => _members.Remove.member);

    public decimal GetTaxAmount()
    {
        return _members.Sum(m => m.GetTaxAmount());
    }

    public decimal GetTaxDiscount()
    {
        return _members.Sum(m => m.GetTaxDiscount());
    }

    public decimal GetTotalTaxYTD()
    {
        return _members.Sum(m => m.GetTotalTaxYTD());
    }
}

在C#中的应用

var alice = new Employee("Alice", 150000, Enumerable.Repeat(25000m, 12).ToList());

var bob = new Employee("Bob", 80000, Enumerable.Repeat(15000m, 12).ToList());

var carol = new Employee("Carol", 120000, Enumerable.Repeat(20000m, 12).ToList());

var dave = new Employee("Dave", 95000, Enumerable.Repeat(18000m, 12).ToList>();

var engineering = new Department("Engineering");
engineering.Add(alice);
engineering.Add(bob);

var design = new Department("Design");
design.Add(carol);
design.Add(dave);

var company = new Department("TechCorp");
company.Add(engineering);
company.Add(design);

Console.WriteLine($"Alice的税额：{alice.GetTaxAmount()}");
Console.WriteLine($"Engineering部门的总税额：{engineering.GetTaxAmount()}`);

// 计算整个公司的总税额
Console.WriteLine($"整个公司的总税额：{company.GetTaxAmount()}`);
Console.WriteLine($"整个公司的总折扣金额：{company.GetTaxDiscount()}");
Console.WriteLine($"整个公司今年至今的总税额：{company.GetTotalTaxYTD()}");

这种结构与Dart语言中的实现方式完全相同。ITaxManager代表组件，Employee代表叶节点，而Department则代表复合节点。这种层次结构是嵌套的：多个Department组合在一起就构成了整个公司。无论访问树中的哪个节点，调用代码都会使用相同的三种方法，从而得到正确的聚合结果。