12. Flyweight享元（结构型模式）

面向对象的代价
     面向对象很好地解决了系统抽象性的问题，同时在大多数情况下，也不会损及系统的性能。但是，在某些特殊的应用中下，由于对象的数量太大，采用面向对象会给系统带来难以承受的内存开销(拆箱操作)。比如图形应用中的图元等对象、字处理应用中的字符对象等。

动机（Motivation）
     采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行时代价——主要指内存需求方面的代价(空间代价)。如何在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明地使用面向对象的方式来进行操作？

意图（Intent）
     运用共享技术有效地支持大量细粒度的对象。
                                                            ——《设计模式》GoF

结构（Structure）

 

using System;
using System.Collections;


Abstract Flyweight#region Abstract Flyweight
public abstract class Order
{
    // 将咖啡卖给客人
    public abstract void Serve(Table table);
    // 返回咖啡的名字
    public abstract string GetFlavor();
}
#endregion

Create Flyweight#region Create Flyweight
public class Flavor : Order
{
    private string flavor;

    // 构造函数，内蕴状态以参数方式传入
    public Flavor(string flavor)
    {
        this.flavor = flavor;
    }

    // 返回咖啡的名字
    public override string GetFlavor()
    {
        return this.flavor;
    }

    // 将咖啡卖给客人
    public override void Serve(Table table)
    {
        Console.WriteLine("Serving table {0} with flavor {1}", table.Number, flavor);
    }
}
#endregion

Flyweight Factory#region Flyweight Factory

public class FlavorFactory
{
    private Hashtable flavors = new Hashtable();

    public Order GetOrder(string key)
    {
        if (!flavors.ContainsKey(key))
            flavors.Add(key, new Flavor(key));

        return ((Order)flavors[key]);
    }

    public int GetTotalFlavorsMade()
    {
        return flavors.Count;
    }
}

#endregion

Client#region Client

public class Table
{
    private int number;

    public Table(int number)
    {
        this.number = number;
    }

    public int Number
    {
        get { return number; }
    }
}

public class Client
{
    private static FlavorFactory flavorFactory;
    private static int ordersMade = 0;

    public static void Main(string[] args)
    {
        flavorFactory = new FlavorFactory();

        TakeOrder("Black Coffee");
        TakeOrder("Capucino");
        TakeOrder("Espresso");
        TakeOrder("Capucino");
        TakeOrder("Espresso");
        TakeOrder("Black Coffee");
        TakeOrder("Espresso");
        TakeOrder("Espresso");
        TakeOrder("Black Coffee");
        TakeOrder("Capucino");
        TakeOrder("Capucino");
        TakeOrder("Black Coffee");

        Console.WriteLine("\nTotal Orders made: " + ordersMade);

        Console.WriteLine("\nTotal Flavor objects made: " +
          flavorFactory.GetTotalFlavorsMade());

        Console.ReadLine();
    }

    private static void TakeOrder(string aFlavor)
    {
        Order o = flavorFactory.GetOrder(aFlavor);

        // 将咖啡卖给客人
        o.Serve(new Table(++ordersMade));
    }
}

#endregion

 

Flyweight模式的几个要点
     • 面向对象很好地解决了抽象性的问题，但是作为一个运行在机器中的程序实体，我们需要考虑对象的代价问题。Flyweight设计模式主要解决面向对象的代价问题，一般不触及面向对象的抽象性问题。
     • Flyweight采用对象共享的做法来降低系统中对象的个数，从而降低细粒度对象给系统带来的内存压力。在具体实现方面，要注意对象状态的处理。
     • 对象的数量太大(采用共享对象解决,共享对象的额外开销是指针.所以共享对象和指针大小[共享对象明显比指针大的情况下]有可比性的形况下,先择共享对象,Flyweight模式一定存在指针)从而导致对象内存开销加大——什么样的数量才算大？这需要我们仔细的根据具体应用情况进行评估，而不能凭空臆断。