享元模式
介绍：
享元模式（Flyweight）：池技术的重要实现方式。运用共享技术有效地支持大量细粒度的对象。
享元模式的定义为我们提出了两个要求：细粒度的对象和共享对象。
要求细粒度对象，那么不可避免地使得对象数量多且性质相近，那我们就将这些对象的信息分为两个部分：内部状态（intrinsic）与外部状态（extrinsic）。
如果分配太多的对象到应用程序中将有损程序的性能，同时还容易造成内存溢出。那怎么避免呢？就是享元模式中提到的共享技术。
内部状态
内部状态时对象可共享出来的信息，存储在享元模式对象内并且不会随环境改变而改变。外部转态
外部状态是对象得以依赖的一个标记，是随环境改变而改变的、不可以共享的状态。结构图
角色
Flyweight抽象享元角色
它简单地说就是一个产品的抽象类，同时定义出对对象的外部状态和内部状态的接口或实现
ConcreteFlyweight具体享元角色
具体的一个产品类，实现抽象角色定义的业务。该角色中需要注意的是内部状态处理应该与环境无关，不应该出现一个操作改变了内部状态，同时修改了外部状态，这是绝对不允许的。
UnsharedConcreteFlyweight不可共享的享元角色
不存在外部状态或者安全要求（如线程安全）不能够使用共享技术的对象，该对象一般不会出现在享元工厂中。
FlyweightFactory享元工厂
职责非常简单，就是构造一个池容器，同时提供从池中获得对象的方法。
基本代码
Flyweight类，它是所有具体的超类或接口，通过这个接口，Flyweight可以接受并作用于外部状态
abstract class Flyweight
{
public abstract void Operation(int extrinsicstate);
}
ConcreteFlyweight是继承Flyweight超类或实现Flyweight接口，并为内部状态增加存储空间
class ConcreteFlyweight : Flyweight
{
public override void Operation(int extrinsicstate)
{
Console.WriteLine("具体Flyweight:"+extrinsicstate);
}
}
UnsharedConcreteFlyweight是指那些不需要共享的Flywei子类。因为Flyweig接口共享成为可能，但它并不强制共享
class UnsharedConcreteweight : Flyweight
{
public override void Operation(int extrinsicstate)
{
Console.WriteLine("不共享的具体Flyweight："+extrinsicstate);
}
}
FlyweigFacory，是一个享元工厂，用来创建并管理Flyweight对象。它主要是用来确保合理地共享Flyweight，当用户请求一个Flyweight时，FlyweightFactory对象提供一个已创建的实例或者创建一个（如果不存在的话）
class FlyweihtFactory
{
private Hashtable flyweithts = new Hashtable();
public FlyweihtFactory()
{
flyweithts.Add("X", new ConcreteFlyweight()); //初始化工厂时，先生成三个实例
flyweithts.Add("Y", new ConcreteFlyweight());
flyweithts.Add("Z", new ConcreteFlyweight());
}
public Flyweight GetFlyweight(string key) //根据客户端请求，获得已生成的实例
{
return ((Flyweight)flyweithts[key]);
}
}
客户端代码
static void Main(string[] args)
{
int extrinsicstate = 22; //代码外部状态
FlyweihtFactory f = new FlyweihtFactory();
Flyweight fx = f.GetFlyweight("X");
fx.Operation(--extrinsicstate);
Flyweight fy = f.GetFlyweight("Y");
fy.Operation(--extrinsicstate);
Flyweight fz = f.GetFlyweight("Z");
fz.Operation(--extrinsicstate);
Flyweight uf = new UnsharedConcreteweight();
uf.Operation(--extrinsicstate);
Console.Read();
}
效果
例子
网站共享
小菜的朋友给小菜介绍了一个小型的外包项目，是给一些私营业主做网站，刚开始是为一个客户座椅产品展示的网站而后，他的另外朋友也希望做这样的网站，但是只是要求有所改动，有的人希望是新闻发布形式的、有的人希望是博客形式的.....如果每个网站租用一个空间，一个数据库，那么不仅的费用上大大超支，在维护上也是非常困难的，所以坚决不能使用复制代码。
如果有100家企业找你做网站，难道还要去申请100个空间，用100个数据库，然后用类似的代码复制100遍？很显然这样是不行的，那么就用到我们上面提到的享元模式。
结构图
用户类， 用于网站的客户账号，是“网站”类的外部状态
用户
public class User
{
private string name;
public User(string name)
{
this.name = name;
}
public string Name
{
get { return name; }
}
}
网站抽象类
abstract class WebSite
{
public abstract void Use(User user); //“使用”方法需要传递“用户”对象
}
具体网站类
class ConcreteWebSite : WebSite
{
private string name = "";
public ConcreteWebSite(string name)
{
this.name = name;
}
public override void Use(User user) //实现"Use"方法
{
Console.WriteLine("网站分类："+name+"用户："+ user.Name);
}
}
网站工厂类
class WebSiteFactory
{
private Hashtable flyweights=new Hashtable();
//获得网站分类
public WebSite GetWebSiteCategory(string key)
{
if (!flyweights.ContainsKey(key))
flyweights.Add(key, new ConcreteWebSite(key));
return ((WebSite)flyweights[key]);
}
//获得网站分类总数
public int GetWebSiteCount()
{
return flyweights.Count;
}
}
客户端代码
static void Main(string[] args)
{
WebSiteFactory f = new WebSiteFactory();
WebSite fx = f.GetWebSiteCategory("产品展示");
fx.Use(new User("小菜"));
WebSite fy = f.GetWebSiteCategory("产品展示");
fy.Use(new User("大鸟"));
WebSite fz = f.GetWebSiteCategory("产品展示");
fz.Use(new User("娇娇"));
WebSite f1 = f.GetWebSiteCategory("博客");
f1.Use(new User("老顽童"));
WebSite f2 = f.GetWebSiteCategory("博客");
f2.Use(new User("桃谷六仙"));
WebSite f3 = f.GetWebSiteCategory("博客");
f3.Use(new User("南海神鳄"));
Console.WriteLine("得到的网站分类总数 {0}", f.GetWebSiteCount());
Console.Read();
}
效果
享元模式的优点
享元模式可以大大减少应用程序创建的对象，降低程序内存的占用，增强程序的性能
享元模式的缺点
提高了系统的复杂性，需要分离出外部状态和内部状态，而且外部状态具有固化特征，不应该随内部状态改变而改变，否则导致系统的逻辑混乱
适用场景
1.系统中存在大量的相似对象
2.细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份
3.需要缓冲池的场景
结束语
享元模式的目的在于运用共享技术，使得一些细粒度的对象可以共享，我们的设计确实也应该这样，多使用细粒度对象，便于重用或重构。