享元模式

1. 项目也别傻做

A: 三个作品展示，三个博客，其实它们本质上都是一样的代码。
B: 共用一套代码，但是毕竟是不同的网站，数据都不相同。
A: 共享代码，为什么不可以呢？比如现在大型的网站，里面的一个博客或商家也可以理解为一个个小的网站，但它们是如何做的？
B: 利用ID的不同，来区分不同的用户，具体数据和模版都是不同，但是代码核心和数据库却是共享的。

2. 享元模式

运用共享技术有效的支持大量细粒度的对象。

class Program
{
    static void Main(string[] args)
    {
        int extrinsicstate = 22;

        FlyweightFactory f = new FlyweightFactory();

        Flyweight fx = f.GetFlyweight("X");
        fx.Operation(--extrinsicstate);

        Flyweight fy = f.GetFlyweight("Y");
        fy.Operation(--extrinsicstate);

        Flyweight fz = f.GetFlyweight("Z");
        fz.Operation(--extrinsicstate);

        UnsharedConcreteFlyweight uf = new UnsharedConcreteFlyweight();

        uf.Operation(--extrinsicstate);

        Console.Read();
    }
}

class FlyweightFactory
{
    private Hashtable flyweights = new Hashtable();

    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]);
    }
}

abstract class Flyweight
{
    public abstract void Operation(int extrinsicstate);
}

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);
    }
}

B: FlyweightFactory根据客户需求返回早已生成好的对象，但一定要事先生成对象实例吗？
A: 实际上是不一定需要，完全可以初始化时什么都不做，到需要时，再去判断对象是否为null来决定是否实例化。
A: UnsharedConcreteFlyweight子类解决那些不需要共享对象的问题。

3. 网站共享代码

class Program
{
    static void Main(string[] args)
    {

        WebSiteFactory f = new WebSiteFactory();

        WebSite fx = f.GetWebSiteCategory("产品展示");
        fx.Use();

        WebSite fy = f.GetWebSiteCategory("产品展示");
        fy.Use();

        WebSite fz = f.GetWebSiteCategory("产品展示");
        fz.Use();

        WebSite fl = f.GetWebSiteCategory("博客");
        fl.Use();

        WebSite fm = f.GetWebSiteCategory("博客");
        fm.Use();

        WebSite fn = f.GetWebSiteCategory("博客");
        fn.Use();

        Console.WriteLine("网站分类总数为 {0}", f.GetWebSiteCount());

        Console.Read();
    }
}

//网站工厂
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;
    }
}

//网站
abstract class WebSite
{
    public abstract void Use();
}

//具体的网站
class ConcreteWebSite : WebSite
{
    private string name = "";
    public ConcreteWebSite(string name)
    {
        this.name = name;
    }

    public override void Use()
    {
        Console.WriteLine("网站分类：" + name);
    }
}

A: 这样有个问题，你给企业建的网站不是一家的企业，它们的数据不会相同，所有至少它们都应该有不同的帐号，你怎么办？
B: 时间上，上面的代码没有体现对象间的不同，只体现了它们的共享部分。

4. 内部状态与外部状态

A: 在享元对象内部并且不会随环境改变而改变的共享部分，可以称为享元对象的内部状态，而随着环境改变而改变，不可以共享的就是外部状态。事实上，享元模式可以避免大量非常相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本相同，有时能够大幅度的减少需要实例化的类的数量。如果能把那些参数移到类实例外面，在方法调用将它们传递进来，就可以通过共享大幅度地减少单个实例的数目。内部状态存储于ConcreteFlyweight对象之中，而外部对象则应该考虑有客户端对象存储或计算，当调用Flyweight对象的操作时，将该状态传递给它。
B: 那你的意识是说，客户的账号是外部状态，应该由专门的对象来处理。

class Program
{
    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 fl = f.GetWebSiteCategory("博客");
        fl.Use(new User("老顽童"));

        WebSite fm = f.GetWebSiteCategory("博客");
        fm.Use(new User("桃谷六仙"));

        WebSite fn = f.GetWebSiteCategory("博客");
        fn.Use(new User("南海鳄神"));

        Console.WriteLine("得到网站分类总数为 {0}", f.GetWebSiteCount());

        //string titleA = "大话设计模式";
        //string titleB = "大话设计模式";

        //Console.WriteLine(Object.ReferenceEquals(titleA, titleB));


        Console.Read();
    }
}

//用户
public class User
{
    private string name;

    public User(string name)
    {
        this.name = name;
    }

    public string Name
    {
        get { return 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;
    }
}

//网站
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)
    {
        Console.WriteLine("网站分类：" + name + " 用户：" + user.Name);
    }
}

5. 享元模式应用

A: 如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的开销时就应该考虑使用，还有就是对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较小的共享对象取代很多组对象，此时可以考虑使用享元模式。
A: 虽说享元模式更多的时候是一种底层的设计模式(数组，字符串共享)，但现实也是有应用的。比如说休闲游戏开放，想围棋，五子棋等，它们都有大量的棋子对象，它们的内部状态和外部状态？
B: 颜色是内部状态和坐标是棋子的外部状态。
A: 享元模式需要维护一个记录了系统已有的所有享元列表，而这本身需要耗费资源，另外享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。因此，应当在有足够的对象实例可工共享时才值得使用享元模式。