image.png

Composite 模式

能够使容器与内容具有一致性，创造出递归结构的模式就是 Composite 模式。

Show me the Codes

image.png

namespace CompositePattern
{
    /// <summary>
    /// 目录条目
    /// </summary>
    internal abstract class Entry
    {
        /// <summary>
        /// 获取名称
        /// </summary>
        /// <returns></returns>
        public abstract string GetName();

        /// <summary>
        /// 获取大小
        /// </summary>
        /// <returns></returns>
        public abstract int GetSize();

        /// <summary>
        /// 打印列表
        /// </summary>
        public void PrintList()
        {
            PrintList("");
        }

        /// <summary>
        /// 打印列表
        /// </summary>
        /// <param name="prefix"></param>
        public abstract void PrintList(string prefix);

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entry"></param>
        /// <returns></returns>
        public abstract Entry Add(Entry entry);

        public override string ToString()
        {
            return $"{GetName()}({GetSize()})";
        }
    }
}

using System;

namespace CompositePattern
{
    /// <summary>
    /// 文件
    /// </summary>
    internal class File : Entry
    {
        private readonly string _name;
        private readonly int _size;

        public File(string name, int size)
        {
            _name = name;
            _size = size;
        }

        public override string GetName()
        {
            return _name;
        }

        public override int GetSize()
        {
            return _size;
        }

        public override void PrintList(string prefix)
        {
            Console.WriteLine($"{prefix}/{this}");
        }

        public override Entry Add(Entry entry)
        {
            throw new Exception("File cannot be added");
        }
    }
}

using System;
using System.Collections.Generic;

namespace CompositePattern
{
    /// <summary>
    /// 目录
    /// </summary>
    internal class Directory : Entry
    {
        public readonly List<Entry> Directories = new List<Entry>();
        private readonly string _name;

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

        public override string GetName()
        {
            return _name;
        }

        public override int GetSize()
        {
            var result = 0;

            foreach (var entry in Directories)
            {
                result += entry.GetSize();
            }

            return result;
        }

        public override void PrintList(string prefix)
        {
            Console.WriteLine($"{prefix}/{this}");

            foreach (var entry in Directories)
            {
                entry.PrintList($"{prefix}/{_name}");
            }
        }

        public override Entry Add(Entry entry)
        {
            Directories.Add(entry);
            return this;
        }
    }
}

using System;

namespace CompositePattern
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var rootDir = new Directory("root");
            var binDir = new Directory("bin");
            var tmpDir = new Directory("tmp");
            var usrDir = new Directory("usr");

            rootDir.Add(binDir);
            rootDir.Add(tmpDir);
            rootDir.Add(usrDir);

            binDir.Add(new File("vi", 10000));
            binDir.Add(new File("latex", 20000));

            rootDir.PrintList();

            Console.Read();
        }
    }
}

image.png
image.png

角色梳理

image.png

Leaf：树叶

表示“内容”的角色，该角色不能放入其它对象。对应示例中的 File 类。

Composite：复合物

表示容器的角色，可以在其中放入 Leaf 角色和 Composite 角色。对应示例的 Directory 类。

Component：组件

使 Leaf 角色和 Composite 角色具有一致性的角色。对应示例的 Entry 类。

Client：客户端

使用 Composite 模式的角色。对应示例的 Program 类

要点&思路

1.使用 Composite 模式可以使容器与内容具有一致性，也可以称其为多个和单个的一致性，即将多个对象结合在一起，当作一个对象进行处理；

相关模式

Command 模式

Visitor 模式

Decorator 模式