组合模式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPattern.StructuralPattern
{
    #region 组合模式要点

    //定义：将对象组合成树形结构来表示 部分-整体的层次结构，使客户端能够使用相同的方式来处理叶节点和容器
    //组合模式实现的最关键的地方是——简单对象和复合对象必须实现相同的接口
    //优点：
    //1.是客户端忽略单个对象和对象容器的区别，使用一致的方式处理
    //2.可以更容易向组合对象添加新的组件
    //
    //使用场景：1.实现树形结构对象 2.使用一致的方式处理简单对象和复杂容器
    /*
      实现方式:
      1.确保应用的核心模型能够以树状结构表示。 尝试将其分解为简单元素和容器。
        容器必须能够同时包含简单元素和其他容器。
      2.声明组件接口及其一系列方法， 这些方法对简单和复杂元素都有意义
        透明模式和安全模式：可将叶节点不需要的行为仅在容器中保留，抽象接口仅定义共同的抽象行为。
      3.创建一个叶节点类表示简单元素。 程序中可以有多个不同的叶节点类。
      4.创建一个容器类表示复杂元素。 在该类中， 创建一个数组成员变量来存储对于其子元素的引用。 
        该数组必须能够同时保存叶节点和容器， 因此请确保将其声明为组合接口类型。
      5.实现组件接口方法时， 记住容器应该将大部分工作交给其子元素来完成。
      6.最后， 在容器中定义添加和删除子元素的方法。
        这些操作可在组件接口中声明。 这会违反接口隔离原则，因为叶节点类中的某些方法会为空。 
        但这可以让客户端无差别地访问所有元素，即使是组成树状结构的元素。  
     */

    #endregion
    public abstract class CompositePattern
    {        
        public string Name { get; set; }
        public CompositePattern(string name)
        {
            Name = name;
        }
        //规定叶节点和容器的行为
        public abstract string Operation();
        public abstract void AddOperation(CompositePattern composite);
        public abstract void DeleteOperation(CompositePattern composite);

        public virtual bool IsComposite() 
        {
            return true;
        }
    }

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

        //叶节点是最小单位，不能增删新的行为
        public override void AddOperation(CompositePattern composite)
        {
            throw new NotImplementedException();
        }

        public override void DeleteOperation(CompositePattern composite)
        {
            throw new NotImplementedException();
        }

        public override string Operation()
        {
            return $"Leaf_{Name} ";
        }
    }

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

        //保存叶节点和容器
        private List<CompositePattern> composites = new List<CompositePattern>();
        public override void AddOperation(CompositePattern composite)
        {
            composites.Add(composite);
        }

        public override string Operation()
        {
            StringBuilder sb = new StringBuilder(48);
            sb.Append("Branch(");
            foreach (var item in composites)
            {
                if (item.IsComposite())
                {
                    sb.Append($"Branch_{Name} ");
                }

                sb.Append(item.Operation());
            }
            sb.Append(")");
            return sb.ToString();
        }

        public override void DeleteOperation(CompositePattern composite)
        {
            composites.Remove(composite);
        }

        public override bool IsComposite()
        {
            return true;
        }
    }
}