Composite 组合模式

本打算写一下用组合模式，结合TreeView控件动态加载对象的例子，由于时间原因，先写个Composite　Pattern吧，

明天再仔细完善之.

组合模式(Composite)：将对象组合成树形结构来表示＂部分-整体＂的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

 

组合模式又可以分为透明模式(Transparent)和安全模式(Security)两种

 例一:透明模式(Transparent)

 class Program
    {
        static void Main(string[] args)
        {
            Component root = new Composite("根");
            root.Add(new Composite("--枝节点1"));
            root.Add(new Composite("--枝节点2"));
            Composite comp = new Composite("--枝节点3");
            Leaf leaf = new Leaf("----叶结点");
            comp.Add(leaf);
            root.Add(comp);
            root.Display();
            Console.Read();
        }
    }

    public abstract class Component
    {
        protected string _name;
        public Component(string name)
        {
            this._name = name;
        }
        public abstract void Add(Component component);
        public abstract void Remove(Component component);
        public abstract void Display();
    }

    /// <summary>
    /// Leaf的在组合中表示节点对象，叶子节点没有子节点
    /// </summary>
    public class Leaf : Component
    {
        public Leaf(string name)
            : base(name)
        {
        }
        /// <summary>
        /// 无意义，只是起到完全一致的接口作用
        /// </summary>
        /// <param name="component"></param>
        public override void Add(Component component)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public override void Remove(Component component)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public override void Display()
        {
            Console.WriteLine(this._name);
        }
    }

    public class Composite : Component
    {
        private List<Component> childList = new List<Component>();
        public Composite(string name)
            : base(name)
        {
        }

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

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

        public override void Display()
        {
            Console.WriteLine(this._name);
            foreach (Component component in childList)
            {
                component.Display();
            }
        }
    }
}

 

 

例二:安全模式(Security)

class Program
    {
        static void Main(string[] args)
        {
            Composite root = new Composite("根");
            root.Add(new Composite("--枝节点1"));
            root.Add(new Composite("--枝节点2"));
            Composite comp = new Composite("--枝节点3");
            Leaf leaf = new Leaf("----叶结点");
            comp.Add(leaf);
            root.Add(comp);
            root.Display();
            Console.Read();
        }
    }

    public abstract class Component
    {
        protected string _name;
        public Component(string name)
        {
            this._name = name;
        }
        public abstract void Display();
    }

    /// <summary>
    /// Leaf的在组合中表示节点对象，叶子节点没有子节点
    /// </summary>
    public class Leaf : Component
    {
        public Leaf(string name)
            : base(name)
        {
        }
        public override void Display()
        {
            Console.WriteLine(this._name);
        }
    }

    public class Composite : Component
    {
        private List<Component> childList = new List<Component>();
        public Composite(string name)
            : base(name)
        {
        }

        public void Add(Component component)
        {
            childList.Add(component);
        }

        public void Remove(Component component)
        {
            childList.Remove(component);
        }

        public override void Display()
        {
            Console.WriteLine(this._name);
            foreach (Component component in childList)
            {
                component.Display();
            }
        }
    }

 

看了一些资料，还有一种方式，即(复合给合模式），先这么这个称法吧

 

class Program
    {
        static void Main(string[] args)
        {
            Component root = new Composite("根");
            root.Childs.Add(new Composite("  --枝节点1"));
            Composite comTmp = new Composite("  --枝节点2");
            root.Childs.Add(comTmp);

            Composite comp = new Composite("  --枝节点3");
            comp.Childs.Add(new Leaf("    --叶结点"));
            root.Childs.Add(comp);

            root.Childs.Remove(comTmp);

  
            root.Display();
            Console.Read();
        }
    }

    public abstract class Component
    {
        protected string _name;
        protected List<Component> childList;
        public Component(string name)
        {
            this._name = name;
            childList = new List<Component>();
        }
        public abstract void Display();

        public List<Component> Childs
        {
            get
            {
                return childList;
            }
        }
    }

    /// <summary>
    /// Leaf的在组合中表示节点对象，叶子节点没有子节点
    /// </summary>
    public class Leaf : Component
    {
        public Leaf(string name)
            : base(name)
        {
        }
        public override void Display()
        {
            Console.WriteLine(this._name);
        }
    }

    public class Composite : Component
    {
        public Composite(string name)
            : base(name)
        {
        }
        public override void Display()
        {
            Console.WriteLine(this._name);
            foreach (Component component in this.Childs)
            {
                component.Display();
            }
        }
    }