设计模式---Composite

  • Composite Pattern
    组合模式(Composite Design Pattern)主要功能是能够使客户端(Client Code) 平等的对待单一组件(Single Componets)和容器组件(Container Componen)。从而实现客户端代码与组件之间的解耦。

  • 适用场景
    Composites that contain Components, each of which could be a Composite.
    组合中包含组件,每个组件有可能也是一个组合。

  • 解决问题
    Application needs to manipulate a hierarchical collection of “primitive” and “composite” objects. Processing of a primitive object is handled one way, and processing of a composite object is handled differently. Having to query the “type” of each object before attempting to process it is not desirable.

  • 模式分析
    在这里插入图片描述
    从上图可以看出,Client依赖与抽象Component,该抽象可以是interface 或abstract类。Leaf和Composite泛化于Component,同时Composite依赖于Component。习惯上称像Leaf这样的Single Componet为叶子组件,Composite这样的Container Componet为树枝,Component为根(root)。该模式主要用在容器组件递归调用。

  • 代码示例
    ASP.Net中控件都有Render方法,控件类型有容器类型(Panel,Form)与非容器类型(Button)。下面代码模拟Form显示窗体上所有控件。

/*
 * composite Pattern
 * 组合模式
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace Pattern01
{
    class Program
    {
        static void Main(string[] args)
        {

            Form form = new Form();
            Button buttonInForm = new Button();

            Console.WriteLine("Container's Render Method excute.");
            form.Add(buttonInForm);
            form.Render();

            Console.WriteLine("Single's Render Method excute.");
            Button button = new Button();
            button.Render();

            Console.ReadKey();

        }


    }

    /// <summary>
    /// Component
    /// </summary>
    public interface IControl
    {
        void Render();
    }
    /// <summary>
    /// Leaf 
    /// </summary>
    public class Button : IControl
    {
        public void Render()
        {
            Console.WriteLine("Button Rended");
        }
    }


    /// <summary>
    /// Composite 
    /// </summary>
    public class Form : IControl
    {
        private List<IControl> controls = new List<IControl>();

        public void Add(IControl control)
        {
            controls.Add(control);
        }

        public void Remove(IControl control)
        {
            controls.Remove(control);
        }

        public void Render()
        {
            Console.WriteLine("Form Rended");

            if (controls != null)
            {
                foreach (var control in controls)
                {
                    control.Render();
                }
            }
        }
    }

}

  • structural code
/*
 *Composite Pattern
 * 可以让client 访问类整体的结构,不管它是一个leaf node,还是一个compont
 * Composites that contain Components, each of which could be a Composite.
 * 
 * 包含组件的组合,每个组件都可以是一个组合。
 */
using System;
using System.Collections.Generic;

namespace Pattern03
{

    class Program
    {

        static void Main(string[] args)
        {
            // Create a tree structure

            Composite root = new Composite("root");
            root.Add(new Leaf("Leaf A"));
            root.Add(new Leaf("Leaf B"));



            Composite comp = new Composite("Composite X");
            comp.Add(new Leaf("Leaf XA"));
            comp.Add(new Leaf("Leaf XB"));

            root.Add(comp);
            root.Add(new Leaf("Leaf C"));


            // Add and remove a leaf

            Leaf leaf = new Leaf("Leaf D");
            root.Add(leaf);
            root.Remove(leaf);

            // Recursively display tree

            root.Display(1);


            Console.ReadKey();

        }

    }
    /// <summary>
    /// 声明组合中对象的接口。
    /// 为所有类通用的接口实现默认行为。
    /// 声明用于访问和管理其子组件的接口。
    /// (可选) 定义一个接口,用于在递归结构中访问组件的父组件,并在适当的情况下实现它。
    /// </summary>
    abstract class Component
    {
        protected string name;
        public Component(string name)
        {
            this.name = name;
        }

        public abstract void Add(Component c);
        public abstract void Remove(Component c);
        public abstract void Display(int depth);
    }
    /// <summary>
    /// 定义具有子组件的行为
    /// 存储子组件。
    /// 在组件接口中实现子操作。
    /// </summary>
    class Composite : Component
    {
        private List<Component> _children = new List<Component>();
        public Composite(string name) : base(name)
        {

        }
        public override void Add(Component c)
        {
            _children.Add(c);
        }
        public override void Remove(Component c)
        {
            _children.Remove(c);
        }
        public override void Display(int depth)
        {
            //这里实现递归调用,如果组件是node--leaf 则直接调用其display方法,如果是组件是composite--组合,
            //则调用 此处的Display--从而实现迭代。


            Console.WriteLine(new string('-', depth) + name);

            foreach (Component component in _children)
            {
                component.Display(depth + 2);//
            }
        }
    }
    /// <summary>
    /// represents leaf objects in the composition. A leaf has no children.没有其他子类
    /// defines behavior for primitive objects in the composition.实现composition中的方法
    /// </summary>
    class Leaf : Component
    {
        public Leaf(string name) : base(name) { }
        public override void Add(Component c)
        {
            Console.WriteLine("Cannot add to a leaf");
        }
        public override void Remove(Component c)
        {
            Console.WriteLine("cannot remove from a leaf");
        }
        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
        }
    }

}

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值