模式简介
运用共享技术有效地支持大量细粒度地对象。
通常情况下，面向对象技术可以增强系统地灵活性及可扩展性，在系统开发过程中，我们会不断地增加类和对象。当对象数量过多时，将会带来系统开销过高、性能下降等问题。享元模式通过共享相同或相似的对象来解决这一类问题。在介绍享元模式之前，首先要弄清楚两个概念：内部状态(Intrinsic State)和外部状态(Extrinsic State)。
内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，因此内部状态可以共享。例如，围棋中的棋子，它们的形状和大小完全相同，那么形状、大小则属于内部状态。
外部状态是随环境改变而改变的、不可以共享的状态。享元对象的外部状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。一个外部状态与另一个外部状态之间是相互独立的。例如，棋子的位置各不相同，那么棋子的位置就属于外部状态。
结构说明
角色说明
Flyweight
抽象享元类。包含一个方法，通过这个方法flyweight可以接受外部状态。
ConcreteFlyweight
具体享元类。实现Flyweight，对象是可共享的。
UnsharedConcreteFlyweight
非共享享元类。享元模式并不强制共享。
FlyweightFactory
享元工厂类。创建并管理Flyweight对象。
源码结构
抽象享元类Flyweight，包含一个抽象方法Operation，并接受一个外部状态extrinsiState。
abstract class Flyweight{ public abstract void Operation(int extrinsicState);
}具体享元类ConcreteFlyweightA和ConcreteFlyweightB，实现具体的Operation方法。
class ConcreteFlyweightA : Flyweight{ public override void Operation(int extrinsicState) {
Console.WriteLine($"ConcreteFlyweightA->Operation[{extrinsicState}]");
}
}class ConcreteFlyweightB : Flyweight{ public override void Operation(int extrinsicState) {
Console.WriteLine($"ConcreteFlyweightB->Operation[{extrinsicState}]");
}
}享元工厂，负责维护一个享元池，用来存储具有相同内部状态的享元对象。
class FlyweightFactory{ private Dictionary<string, Flyweight> _flyweights = new Dictionary<string, Flyweight>(); public Flyweight GetFlyweight(string key) {
Flyweight flyweight; if (_flyweights.ContainsKey(key))
{
Console.WriteLine("Already in the pool , use the exist one.");
flyweight = _flyweights[key];
} else
{ switch (key)
{ case "A":
flyweight = new ConcreteFlyweightA(); break; case "B":
flyweight = new ConcreteFlyweightB(); break; default: throw new Exception("Don't support this key");
}
_flyweights.Add(key, flyweight);
} return _flyweights[key];
}
}通过向工厂传入不同的key值，获取相应的享元对象。
class Program{ static void Main(string[] args) {
FlyweightFactory factory = new FlyweightFactory();
Flyweight fw = factory.GetFlyweight("A"); int extrinsicState = 1;
fw.Operation(extrinsicState);
Flyweight fw2 = factory.GetFlyweight("B");
fw2.Operation(extrinsicState);
extrinsicState = 2;
Flyweight fw3 = factory.GetFlyweight("A");
fw3.Operation(extrinsicState);
Console.ReadLine();
}
}输出结果：
工作原理
ConcreteFlyweight对象存储内部状态，由Client计算或存储外部状态并传递给享元对象。
用户通过FlyweightFactory对象获取ConcreteFlyweight对象，从而确保享元对象的共享。
示例分析
想象一款围棋游戏，棋盘中包含大量的黑子和白子。当然我们不能为每个棋子创建一个对象，这种设计代价太大，随着游戏的不断进行，软件占用内存会越来越大。棋子的形状、大小完全相同(内部状态)，位置发生变化(外部状态)。
首先创建享元类Chessman，包含抽象方法Display，这里以x,y表示坐标位置。
abstract class Chessman{ public abstract void Display(int x, int y);
}创建具体享元类，为了使用方便，加入Color枚举。
class WhiteChessman : Chessman{ public override void Display(int x, int y) {
Console.WriteLine($"While Chessman , Position:X=>{x},Y=>{y}");
}
}class BlackChessman : Chessman{ public override void Display(int x, int y) {
Console.WriteLine($"Black Chessman , Position:X=>{x},Y=>{y}");
}
}public enum Color
{
White,
Black
}创建Chessman工厂，维护一个享元池，如果享元池中包含请求的对象，则直接返回；如果不包含，则根据请求的颜色创建相应的对象，并添加至享元池中，最后返回给客户端。
class ChessmanFactory{ private Dictionary<Color, Chessman> _chessman = new Dictionary<Color, Chessman>(); public Chessman GetChessman(Color color) {
Chessman chessman; if (_chessman.ContainsKey(color))
{
Console.WriteLine("Already in the pool , use the exist one.");
chessman = _chessman[color];
} else
{
Console.WriteLine("new object"); switch (color)
{ case Color.White:
chessman = new WhiteChessman();
_chessman.Add(color,chessman); break; case Color.Black:
chessman = new BlackChessman();
_chessman.Add(color, chessman); break; default: throw new Exception("Don't support this color");
}
} return chessman;
}
}客户端调用
class Program{
static void Main(string[] args)
{ ChessmanFactory factory = new ChessmanFactory();
var chessmanA = factory.GetChessman(Color.White);
chessmanA.Display(1,1);
var chessmanB = factory.GetChessman(Color.Black);
chessmanB.Display(4, 3);
var chessmanC = factory.GetChessman(Color.White);
chessmanC.Display(5, 10); Console.ReadLine();
}
}使用场景
一个系统中含有大量的相似或相同的对象，由于这些对象的大量使用，消耗大量的内存。
对象的大部分状态可以外部化，由客户端将这些外部状态传入对象中。
由于享元模式需要维护一个存储享元对象的享元池，所以仅当在多次重复使用享元对象时才值得使用享元模式。
优缺点
优点
极大地减少了内存中对象的数量，使得相同或相似的对象在内存中只保留一份。
享元模式的外部状态相对独立，不会影响其内部状态，从而使得享元对象可以在不同环境中被共享。
缺点
系统逻辑更加复杂，需要分离出外部状态和内部状态。
客户端计算并存储外部状态，导致系统运行时间变长。从某种程度上来说，享元模式是一种以时间换空间的解决方案。
随时随地看视频
