小话设计模式（十一）享元模式

享元（Fly Weight直译作蝇量）模式运用共享技术有效的支持大量细颗粒的对象。

一般使用享元模式的时候要满足下列所有情况：

1、 一个应用程序使用了大量的对象。

2、 完全由于使用大量的对象，造成了很大的存储开销。

3、 对象的大多数状态都可以变外外部状态。

4、 如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。

5、 应用程序不依赖与对象标识。

举个例子

一个RPG游戏，怪兽或者英雄都可以改变等级，改变等级之后，二者的攻击力都会发生变化。我们将等级数据（每一级对应的攻击力）存放在本地数据文件里。当我们需要创建一个对象的时候，就要获取这些等级数据。

游戏里的等级数据定义如下：

public abstract class LevelData
{
protected virtual void LoadFromFile (string filePath)
{
//TODO:
}
public abstract int GetAttack (ClientData data);
}

这些数据都是从本地数据文件中读取出来的，这些数据对于每个怪兽都是一样的，所以是共享数据。而且，这些数据是不会变的，除非修改数据文件。

这里提供了一个GetAttack的公开方法，用于获取（怪兽、英雄）攻击力

怪兽等级数据：

public class MonsterLevelData : LevelData
{
public int ID { get; private set;}
public MonsterLevelData(int monID)
{
ID = monID;
//For different heroes, load different files.
LoadFromFile (monID.ToString());
}

private List<int> _levelAttackList = new List<int> ();//Loaded in the method LoadFromFile
protected override void LoadFromFile(string filePath)
{
base.LoadFromFile (filePath);
//TEST
for (int i = 1; i <= 10; i++) {
_levelAttackList.Add (i * 10);
}
}

public override int GetAttack (ClientData data)
{
int lv = data.Level;
lv = System.Math.Min (System.Math.Max (lv, 1), 10);
int attack = _levelAttackList [lv - 1];
return attack + data.AttackPlus;
}
}

接着，我们定义了怪兽的类，包含了怪兽的等级和攻击力加成。在创建怪兽对象的时候，我们就可以根据这两个值的不同，获取不同的攻击力。因为是可变的，所以被定义为外部数据：

public class ClientData
{
public int Level {get;set;}
public int AttackPlus { get; set;}
}

那么如何共享对象呢？这里需要建立一个享元工厂：

public static class LevelDataFactory
{
public static Dictionary<int, LevelData> _monsterLevelData = new Dictionary<int, LevelData>();
public static LevelData GetMonsterLevelData(int monID)
{
if (!_monsterLevelData.ContainsKey (monID)) {
_monsterLevelData [monID] = new MonsterLevelData (monID);
}
return _monsterLevelData [monID];
}
}

因为我们希望相同的怪兽应该拥有相同的等级数据，所以我们使用这样一个享元工厂来创建等级数据，对于相同的怪兽，它们共享同一个等级数据。

使用：

LevelData levelData = LevelDataFactory.GetMonsterLevelData (1);
ClientData monster = new ClientData ();
monster.Level = 3;
monster.AttackPlus = 5;
Console.WriteLine (levelData.GetAttack(monster));

这里有一个问题，因为将等级、攻击加成等信息当做外部状态，放在了ClientData里，我们修改这些值得时候，是修改ClientData的实例，但是获取最终结果的时候，却调用的是levelData的方法GetAttack。这样不是很方便，并且容易造成困扰。所以我们可以考虑修改享元模式，把GetAttack的方法写在用户数据里。
为LevelData增加一个抽象方法：

public abstract int GetLevelAttack(int lv);

MonsterLevelData里添加实现：

public override int GetLevelAttack(int lv)
{
lv = System.Math.Min (System.Math.Max (lv, 1), 10);
return _levelAttackList[lv - 1];
}

创建继承自ClientData的Monster类：

public class Monster : ClientData
{
LevelData _levelData;
public Monster(int monID)
{
_levelData = LevelDataFactory.GetMonsterLevelData (monID);
}
public int GetAttack()
{
return _levelData.GetLevelAttack (Level) + AttackPlus;
}
}

使用：

Monster mon = new Monster (2);
mon.Level = 3;
mon.AttackPlus = 4;
Console.WriteLine (mon.GetAttack ());

这样就将内部状态里的方法移动到了外部状态里。调用很方便，也节省了内存。

享元模式的优点在于：减少了运行时对象实例的个数，节省了内存，并且可以集中管理对象的多个状态。

缺点也很明显：个体之间无法相对独立，拥有不同的行为。