C#面向对象设计模式纵横谈 学习笔记12 FlyWeight享元模式（结构型模式）

在我们面向对象编程时，我们会经常将很多对象封装在一起，成为对象A，如果A中的某个对象所占用的内存比较大，同时我们需要创建很多对象A，我们需要一种设计模式来解决这个问题。打个比方，假设有一个网络游戏，同时有很多用户在线，那么我们就要创建很多网游用户对象，但是每个用户对象都包含了衣服对象，但是这个衣服对象的类别就3中，我们肯定不希望为每个用户来创建一个衣服对象，那么我们就将衣服对象放入一个共享池里，那么所有的用户都使用这个共享池里面的衣服，我们就通过这种方式来节省了衣服这快的内存。

1.  class User
2.     {
3.         /// <summary>
4.         /// 用户名
5.         /// </summary>
6.         string Name;
7.         /// <summary>
8.         /// 用户武器
9.         /// </summary>
10.         string Weapon;
11.         /// <summary>
12.         /// 用户性别
13.         /// </summary>
14.         string Gender;
15.         /// <summary>
16.         /// 用户衣服
17.         /// </summary>
18.         public UserClother Clother;
19.     }
21.     class UserClother
22.     {
23.         /// <summary>
24.         /// 衣服名，确定衣服的唯一性
25.         /// </summary>
26.         string ClotherName;
28.         /// <summary>
29.         /// 衣服的其他属性
30.         /// </summary>
31.         string OtherProfile;
33.         public UserClother(string ClotherName)
34.         {
35.             this.ClotherName = ClotherName;
36.         }
37.     }
39.     static class UserClotherFactory
40.     {
41.         private static Hashtable clotherList = new Hashtable();
43.         public static UserClother GetUserClose(string ClotherName)
44.         {
45.             //从共享池中得到衣服对象
46.             UserClother clother = clotherList[ClotherName] as UserClother;
48.             //如果共享池里面不存在这个对象那么就创建这个对象,并加入到共享池中
49.             if (clother == null)
50.             {
51.                 clother = new UserClother(ClotherName);
52.                 clotherList.Add(ClotherName, clother);
53.             }
55.             return clother;
56.         }
57.     }
60.     class Program
61.     {
62.         static void Main(string[] args)
63.         {
64.             Console.WriteLine(GC.GetTotalMemory(false)); 
66.             //假设有10万个用户在线
67.             ArrayList userList = new ArrayList(100000);
68.             
69.             //假设衣服有三种
70.             string clother1 = "Clother1";
71.             string clother2 = "Clother2";
72.             string clother3 = "Clother3";
74.             User objUser = null;
76.             for (int i = 0; i < 100000; i++)
77.             {
78.                 if (i % 3 == 0)
79.                 {
80.                     objUser = new User();
81.                     objUser.Clother = UserClotherFactory.GetUserClose(clother1);
82.                     //objUser.Clother = new UserClother(clother1);
83.                 }
84.                 else if (i % 3 == 1)
85.                 {
86.                     objUser = new User();
87.                     objUser.Clother = UserClotherFactory.GetUserClose(clother2);
88.                     //objUser.Clother = new UserClother(clother2);
89.                 }
90.                 else if (i % 3 == 2)
91.                 {
92.                     objUser = new User();
93.                     objUser.Clother = UserClotherFactory.GetUserClose(clother3);
94.                     //objUser.Clother = new UserClother(clother3);
95.                 }
96.                 userList.Add(objUser);
97.             }
98.             Console.WriteLine(GC.GetTotalMemory(false));
100.             Console.ReadLine(); 
102.         }
103.     }
104. Main函数里注销的代码是不使用享元模式的代码。我们可以看到，在有10万用户使用的时候，我们衣服的对象始终只有3个，而不是30万个，这样我们就大大的节省了内存。
105. 现在我们可以知道了享元模式使用在对象中有大量耗费了大量内存的细粒度对象，并且对外界来说这些对没有任何差别的（或者说经过改造后可以是没有差别的）。如果衣服有很多种，各式各样，如有10万种组合，那么使用享元模式基本上没有什么意义（节省不了多少内存），因为维护共享池的内存开销与直接在用户对象里指定新的衣服对象使用的内存差别不大。
106. 实现要点

     　　享元工厂维护一张享元实例表。

     　　享元不可共享的状态需要在外部维护。

     　　按照需求可以对享元角色进行抽象。

     注意事项

     　　享元模式通常针对细粒度的对象，如果这些对象比较拥有非常多的独立状态(不可共享的状态)，或者对象并不是细粒度的，那么就不适合运用享元模式。维持大量的外蕴状态不但会使逻辑复杂而且并不能节约资源。

     　　享元工厂中维护了享元实例的列表，同样也需要占用资源，如果享元占用的资源比较小或者享元的实例不是非常多的话(和列表元素数量差不多)，那么就不适合使用享元，关键还是在于权衡得失