【设计模式】享元模式(C#)

古文康

2023-12-01

【设计模式】享元模式

1、概述

Flyweight Design Pattern，结构型模式。享元模式中的“享元”指被共享的单元。享元模式通过复用对象，以达到节省内存的目的。

用于减少创建对象的数量，以减少内存占用和提高性能。尝试复用现有的同类对象，如果未找到匹配的对象，则创建新对象。

运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率。

享元（Flyweight ）模式中存在以下两种状态：

内部状态，即不会随着环境的改变而改变的可共享部分。
外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

享元模式的主要有以下角色：

抽象享元角色（Flyweight）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。
具体享元（Concrete Flyweight）角色：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
非享元（Unsharable Flyweight)角色：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

2、实现思路

【例】象棋

一个游戏厅中有成千上万个“房间”，每个房间对应一个棋局。棋局要保存每个棋子的数据，比如：棋子类型（将、相、士、炮等）、棋子颜色（红方、黑方）、棋子在棋局中的位置。利用这些数据，我们就能显示一个完整的棋盘给玩家。

代码如下：

象棋有不同的类型、颜色，我们可以对这些向上抽取出AbstractPiece，用来定义共性的属性和行为。

public abstract class AbstractPiece
    {
        /// <summary>
        /// Id
        /// </summary>
        public int Id { get; set; }

        /// <summary>
        /// 车:Rooks
        /// 马:Knights(Mao)
        /// 象/相:Elephants
        /// 士/仕:Mandarins
        /// 将/帅:King /General
        /// 炮:Cannons(Pao)
        /// 卒/兵:Pawns
        /// </summary>
        public string Text { get; set; }

        /// <summary>
        /// 红/黑方
        /// </summary>
        public Color Color { get; set; }

        /// <summary>
        /// 棋盘X轴位置
        /// </summary>
        public int PositionX { get; set; }

        /// <summary>
        /// 棋盘Y轴位置
        /// </summary>
        public int PositionY { get; set; }

        public AbstractPiece(string text, Color color, int id) 
        {
            this.Text = text;
            this.Color = color;
            this.Id = id;
        }

        /// <summary>
        /// 获取棋子Text
        /// </summary>
        public string getPiece()
        {
            return this.Text;
        }

    }

接下来就是定义不同的类型了。

public class CannonPiece : AbstractPiece
    {
        public CannonPiece(string text, Color color, int id) : base(text, color, id)
        {

        }
    }

public class KnightPiece:AbstractPiece
    {
        public KnightPiece(string text, Color color, int id) : base(text, color, id)
        {

        }
    }

public class RookPiece : AbstractPiece
    {
        public RookPiece(string text, Color color, int id):base(text, color,id)
        { 
        
        }
    }

提供了一个工厂类（PieceFactory），用来管理享元对象（也就是AbstractPiece子类对象），该工厂类对象只需要一个，所以可以使用单例模式。并给工厂类提供一个获取类型的方法。

public class PieceFactory
    {
        private Dictionary<string, AbstractPiece> picees;
        private PieceFactory()
        {
            picees = new Dictionary<string, AbstractPiece>();
            picees.Add("红车",new RookPiece("车",Color.Red,1));
            picees.Add("红炮", new CannonPiece("炮", Color.Red, 2));
            picees.Add("红马", new KnightPiece("马", Color.Red, 3));
            picees.Add("黑车", new RookPiece("车", Color.Red, 4));
            picees.Add("黑炮", new CannonPiece("炮", Color.Red, 5));
            picees.Add("黑马", new KnightPiece("马", Color.Red, 6));
        }

        private static PieceFactory _Instance = new PieceFactory();
        public static PieceFactory CreateSingleton()
        {
            return _Instance;
        }

        public AbstractPiece getPiece(string key)
        {
            return picees[key];
        }
    }

最后，我们验证一下：

class Program
    {
        static void Main(string[] args)
        {
            PieceFactory piece = PieceFactory.CreateSingleton();
            AbstractPiece piece1 = piece.getPiece("红车");
            AbstractPiece piece2 = piece.getPiece("红炮");
            AbstractPiece piece3 = piece.getPiece("红马");
            AbstractPiece piece4 = piece.getPiece("黑马");
            AbstractPiece piece5 = piece.getPiece("黑马");
            piece5.PositionX = 1;
            piece5.PositionY = 2;

            piece4.PositionX = 3;
            piece4.PositionY = 4;

            Console.WriteLine($"红车和红炮是否一个对象{piece1 == piece2}");
            Console.WriteLine($"红马和黑马是否一个对象{piece3 == piece4}");
            Console.WriteLine($"获取两次的黑马是否一个对象{piece4 == piece5}");
        }
    }
******************【运行结果】****************** 
红车和红炮是否一个对象False
红马和黑马是否一个对象False
获取两次的黑马是否一个对象True

利用工厂类缓存棋子的信息（也就是id、text、color）。通过工厂类获取到的AbstractPiece就是享元。所有的棋盘对象共享这32个AbstractPiece对象（因为象棋中只有32个棋子）。在使用享元模式之前，记录1万个棋局，我们要创建32万（32*1万）个棋子的AbstractPiece对象。利用享元模式，我们只需要创建32个享元对象供所有棋局共享使用即可，大大节省了内存。

主要通过工厂模式，在工厂类中，通过字典缓存已创建过的享元对象，达到复用。

3、优缺点和使用场景

3.1 优点

极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能
享元模式中的外部状态相对独立，且不影响内部状态

3.2 缺点：

为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

3.3 使用场景：

一个系统有大量相同或者相似的对象，造成内存的大量耗费。
对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

4、对比

4.1 V.S 单例

单例模式，一个类只能创建一个对象。
享元模式，一个类可以创建多个对象，每个对象被多处代码引用共享。实际上，享元模式有点类似于之前讲到的单例的变体：多例。

区别设计模式，不能光看代码，而要看设计意图，即要解决啥问题。享元模式是为对象复用，节省内存，单例模式是为限制对象个数。

4.2 V.S 缓存

享元模式实现，通过工厂类来“缓存”已经创建好的对象。这里的“缓存”实际上是“存储”的意思，跟我们平时所说的“数据库缓存”“CPU缓存”“MemCache缓存”是两回事。我们平时所讲的缓存，主要是为了提高访问效率，而非复用。

5、总结

所谓“享元”，顾名思义就是被共享的单元。享元模式的意图是复用对象，节省内存，前提是享元对象是不可变对象。具体来讲，当一个系统中存在大量重复对象的时候，我们就可以利用享元模式，将对象设计成享元，在内存中只保留一份实例，供多处代码引用，这样可以减少内存中对象的数量，以起到节省内存的目的。实际上，不仅仅相同对象可以设计成享元，对于相似对象，我们也可以将这些对象中相同的部分（字段），提取出来设计成享元，让这些大量相似对象引用这些享元。

【设计模式】享元模式(C#)