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