设计模式之享元模式
名词解释：
享元模式(Flyweight)：运用共享技术有效地支持大量细粒度的对象。
必要元素：
1.一个享元工厂，用来创建并管理Flyweight对象。它主要是用来确保合理地共享Flyweight，当用户请求一个Flyweight时，FlyweightFactory对象提供一个已创建的实例或者创建一个(如果不存在)；
2.所有具体享元类的父类或接口，通过这个接口，Flyweight可以接受并作用于外部状态；
3.继承Flyweight父类或者实现Flyweight接口，并为内部状态增加存储空间；
4.指那些不需要共享的Flyweight子类，因为Flyweight接口共享成为可能，但是并不强制共享(即那些不能共享的部分)。
上例子：
Flyweight享元抽象类：
abstract class Flyweight { public abstract void Operation(int extrinsicstate); }
Flyweight具体共享类：
class ConcreteFlyweight:Flyweight { public override void Operation(int extrinsicstate) { Console.WriteLine("具体Flyweight："+extrinsicstate); } } class UnsharedConcreteFlyweight:Flyweight { public override void Operation(int extrinsicstate) { Console.WriteLine("不共享的具体Flyweight："+extrinsicstate); } }
享元工厂：
class FlyweightFactory { private Dictionary<string, Flyweight> flyweights = new Dictionary<string, Flyweight>(); public FlyweightFactory() { flyweights.Add("X", new ConcreteFlyweight()); flyweights.Add("Y", new ConcreteFlyweight()); flyweights.Add("Z", new ConcreteFlyweight()); } public Flyweight GetFlyweight(string key) { return (Flyweight)flyweights[key]; } }
调用：
//外部状态 int extrinsicstate = 22; FlyweightFactory factory = new FlyweightFactory(); Flyweight fx = factory.GetFlyweight("X"); fx.Operation(--extrinsicstate); Flyweight fy = factory.GetFlyweight("Y"); fx.Operation(--extrinsicstate); Flyweight fz = factory.GetFlyweight("Z"); fz.Operation(--extrinsicstate); Flyweight uf = new UnsharedConcreteFlyweight(); uf.Operation(--extrinsicstate); Console.Read();
通过享元类父类和子类(共享和非共享部分)以及享元类工厂，构成了享元模式，这样在使用的时候就不会创建多次对象，有效的利用资源。
例子2(假设有一个网站类，而网站有很多种类型)：
抽象类：
/// <summary> /// 网站抽象类 /// </summary> abstract class WebSite { public abstract void Use(); }
具体网站类：
/// <summary> /// 具体网站类 /// </summary> class ConcreteWebSite:WebSite { private string name = ""; public ConcreteWebSite(string name) { this.name = name; } public override void Use() { Console.WriteLine("网站分类："+name); } }
网站工厂类：
/// <summary> /// 网站工厂 /// </summary> class WebSiteFactory { private Dictionary<string, WebSite> flyweights = new Dictionary<string, WebSite>(); /// <summary> /// 获得网站分类 /// </summary> /// <param name="key"></param> /// <returns></returns> public WebSite GetWebSite(string key) { if (!flyweights.ContainsKey(key)) { flyweights.Add(key, new ConcreteWebSite(key)); } return flyweights[key]; } public int GetWebSiteCount() { return flyweights.Count; } }
使用：
WebSiteFactory factory = new WebSiteFactory(); WebSite fx = factory.GetWebSite("产品展示"); fx.Use(); WebSite fy = factory.GetWebSite("产品展示"); fy.Use(); WebSite fz = factory.GetWebSite("产品展示"); fz.Use(); WebSite fl = factory.GetWebSite("博客"); fl.Use(); WebSite fm = factory.GetWebSite("博客"); fm.Use(); WebSite fn = factory.GetWebSite("博客"); fn.Use(); Console.WriteLine("共有网站{0}个",factory.GetWebSiteCount()); Console.Read();
这样设计基本实现了享元模式的共享对象的目的，也就是说不管创建几个网站，只要是某一类型(博客或者其他)，都是完全相同的，但是问题又来了，不同公司的网站应该有不同的账号，所以我们只是体现了共享的部分，还有非共享部分等待我们实现。
实例2(集成非共享代码)：
外部状态类(User类)：
/// <summary> /// 用户类(外部状态) /// </summary> class User { private string name; public string Name { get { return name; } } public User(string name) { this.name = name; } }
抽象网站类：
/// <summary> /// 网站抽象类 /// </summary> abstract class WebSite { public abstract void Use(User user); }
方法增加了参数，参数为外部状态对象User。
具体网站类：
/// <summary> /// 具体网站类 /// </summary> class ConcreteWebSite:WebSite { private string name = ""; public ConcreteWebSite(string name) { this.name = name; } public override void Use(User user) { Console.WriteLine("网站分类："+name+" 用户："+user.Name); } }
变化也是User函数添加User对象参数。
工厂：无变化。
使用：
WebSiteFactory factory = new WebSiteFactory(); WebSite fx = factory.GetWebSite("产品展示"); fx.Use(new User("Colors")); WebSite fy = factory.GetWebSite("产品展示"); fy.Use(new User("Blue")); WebSite fz = factory.GetWebSite("产品展示"); fz.Use(new User("Listen")); WebSite fl = factory.GetWebSite("博客"); fl.Use(new User("Colors.Blue")); WebSite fm = factory.GetWebSite("博客"); fm.Use(new User("Listen.Fly")); WebSite fn = factory.GetWebSite("博客"); fn.Use(new User("李莫愁")); Console.WriteLine("共有网站{0}个",factory.GetWebSiteCount()); Console.Read();
这样虽然是同一个类型的网站，但是有了User这个外部状态对象，所以就可以把内部状态与外部状态很好的结合。
总结：
如果一个应用程序使用了大量的对象，而大量的对象造成了很大的存储开销时就应该考虑使用享元模式；对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元对象。在实际应用中，使用了享元模式实例总数就大大减少了。
