设计模式——组合模式

初识

组合模式(Composite),将对象组合成树形结构来表现”部分-整体“的层次结构,使得客户以一致的方式处理单个对象以及对象的组合。
组合模式实现的最关键的地方是——简单对象和复合对象必须实现相同的接口。这就是组合模式能够将组合对象和简单对象进行一致处理的原因。

结构

在这里插入图片描述

角色:

  • 组合部件(Component):它是一个抽象角色,为要组合的对象提供统一的接口。
  • 叶子(Leaf):在组合中表示子节点对象,叶子节点不能有子节点。
  • 合成部件(Composite):定义有枝节点的行为,用来存储部件,实现在Component接口中的有关操作,如增加(Add)和删除(Remove)。

实现

/// <summary>
/// 一个抽象构件,声明一个接口用于访问和管理Component的子部件
/// </summary>
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(int level);
}
 
/// <summary>
/// 叶子节点
/// </summary>
public class Leaf : Component
{
    public Leaf(string name)
        : base(name)
    { }
 
    /// <summary>
    /// 由于叶子节点没有子节点,所以Add和Remove方法对它来说没有意义,但它继承自Component,这样做可以消除叶节点和枝节点对象在抽象层次的区别,它们具备完全一致的接口。
    /// </summary>
    /// <param name="component"></param>
    public override void Add(Component component)
    {
        Console.WriteLine("Can not add a component to a leaf.");
    }
 
    /// <summary>
    /// 实现它没有意义,只是提供了一个一致的调用接口
    /// </summary>
    /// <param name="component"></param>
    public override void Remove(Component component)
    {
        Console.WriteLine("Can not remove a component to a leaf.");
    }
 
    public override void Display(int level)
    {
        Console.WriteLine(new string('-', level) + name);
    }
}
 
/// <summary>
/// 定义有枝节点的行为,用来存储部件,实现在Component接口中对子部件有关的操作
/// </summary>
public class Composite : Component
{
    public Composite(string name)
        : base(name)
    { }
 
    /// <summary>
    /// 一个子对象集合,用来存储其下属的枝节点和叶节点
    /// </summary>
    private List<Component> children = new List<Component>();
 
    /// <summary>
    /// 增加子节点
    /// </summary>
    /// <param name="component"></param>
    public override void Add(Component component)
    {
        children.Add(component);
    }
 
    /// <summary>
    /// 移除子节点
    /// </summary>
    /// <param name="component"></param>
    public override void Remove(Component component)
    {
        children.Remove(component);
    }
 
    public override void Display(int level)
    {
        Console.WriteLine(new string('-', level) + name);
 
        // 遍历其子节点并显示
        foreach (Component component in children)
        {
            component.Display(level + 2);
        }
    }
}
 
/// <summary>
/// 调用
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
    //生成树根,并为其增加两个叶子节点
    Component root = new Composite("Root");
    root.Add(new Leaf("Leaf A in Root"));
    root.Add(new Leaf("Leaf B in Root"));
 
    //为根增加两个枝节点
    Component branchX = new Composite("Branch X in Root");
    Component branchY = new Composite("Branch Y in Root");
    root.Add(branchX);
    root.Add(branchY);
 
    //为BranchX增加叶子节点
    branchX.Add(new Leaf("Leaf C in Branch X"));
 
    //为BranchX增加枝节点
    Component branchZ = new Composite("Branch Z in Branch X");
    branchX.Add(branchZ);
 
    //为BranchY增加叶节点
    branchY.Add(new Leaf("Leaf D in Branch Y"));
 
    //为BranchZ增加叶节点
    branchZ.Add(new Leaf("Leaf E in Branch Z"));
 
    //显示树
    root.Display(1);
    
	console.Read();
}

以下是我根据代码画的树图:
在这里插入图片描述
运行结果:
在这里插入图片描述

透明方式与安全方式

  • 在Component中声明所有来管理子对象的方法,其中包括Add,Remove等。这样实现Component接口的所有子类都具备了Add和Remove方法。这样做的好处是叶节点和枝节点对于外界没有区别,它们具备完全一致的接口。上面代码即为透明方式的组合模式。
  • 在Component中不去声明Add和Remove方法,那么子类的Leaf就不需要实现它,而是在Composit声明所有用来管理子类对象的方法。下面来看看安全方式的组合模式代码结构。
/// <summary>
/// 一个抽象构件,声明一个接口用于访问和管理Component的子部件
/// </summary>
public abstract class Component
{
    protected string name;
 
    public Component(string name)
    {
        this.name = name;
    }
 
    /// 显示层级结构
    public abstract void Display(int level);
}
 
/// <summary>
/// 叶子节点
/// </summary>
public class Leaf : Component
{
    public Leaf(string name)
        : base(name)
    { }
    
    public override void Display(int level)
    {
        Console.WriteLine(new string('-', level) + name);
    }
}
 
/// <summary>
/// 定义有枝节点的行为,用来存储部件,实现在Component接口中对子部件有关的操作
/// </summary>
public class Composite : Component
{
    public Composite(string name)
        : base(name)
    { }
 
    /// <summary>
    /// 一个子对象集合,用来存储其下属的枝节点和叶节点
    /// </summary>
    private List<Component> children = new List<Component>();
 
    /// <summary>
    /// 增加子节点
    /// </summary>
    /// <param name="component"></param>
    public void Add(Component component)
    {
        children.Add(component);
    }
 
    /// <summary>
    /// 移除子节点
    /// </summary>
    /// <param name="component"></param>
    public void Remove(Component component)
    {
        children.Remove(component);
    }
 
    public override void Display(int level)
    {
        Console.WriteLine(new string('-', level) + name);
 
        // 遍历其子节点并显示
        foreach (Component component in children)
        {
            component.Display(level + 2);
        }
    }
}
 
/// <summary>
/// 调用
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
    // 生成树根,并为其增加两个叶子节点
    Composite.Composite root = new Composite("Root");
    root.Add(new Leaf("Leaf A in Root"));
    root.Add(new Leaf("Leaf B in Root"));
 
    // 为根增加两个枝节点
    Composite.Composite branchX = new Composite("Branch X in Root");
    Composite.Composite branchY = new Composite("Branch Y in Root");
    root.Add(branchX);
    root.Add(branchY);
 
    // 为BranchX增加页节点
    branchX.Add(new Leaf("Leaf C in Branch X"));
 
    // 为BranchX增加枝节点
    Composite.Composite branchZ = new Composite("Branch Z in Branch X");
    branchX.Add(branchZ);
 
    // 为BranchY增加叶节点
    branchY.Add(new Leaf("Leaf D in Branch Y"));
 
    // 为BranchZ增加叶节点
    branchZ.Add(new Leaf("Leaf E in Branch Z"));
 
    // 显示树
    root.Display(1);
    
	console.Read();
}

缺点

  • 组合方式弊端:客户端对叶节点和枝节点是一致的,但叶节点并不具备Add和Remove的功能,因而对它们的实现是没有意义的。
  • 安全方式弊端:叶节点无需在实现Add与Remove这样的方法,但是对于客户端来说,必须对叶节点和枝节点进行判定,为客户端的使用带来不便。
  • 使得设计更加复杂。客户端需要花更多时间理清类之间的层次关系。(这个是几乎所有设计模式所面临的问题)。

优点

  • 组合模式使得客户端代码可以一致地处理对象和对象容器,无需关系处理的单个对象,还是组合的对象容器。
  • 将客户代码与复杂的对象容器结构“解耦”。
  • 可以更容易地往组合对象中加入新的构件。

使用情景

  • 当想表达对象的部分-整体的层次结构时。
  • 希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象时。

Foreach使用

foreach循环用于列举出集合中所有的元素,语句经常与数组一起使用。foreach语句中的表达式由关键字in隔开的两个项组成。in右边的项是集合名,in左边的项是变量名,用来存放该集合中的每个元素。

该循环的运行过程如下:每一次循环时,从集合中取出一个新的元素值。放到只读变量中去,如果括号中的整个表达式返回值为true,foreach块中的语句就能够执行。一旦集合中的元素都已经被访问到,整个表达式的值为false,控制流程就转入到foreach块后面的执行语句。

评论 28
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值