C#--设计模式之享元模式

这几天项目比较忙，感觉已经隔了半个世纪没来园里转了，接着上次的设计模式来继续说吧，这会来叙说一下享元模式，首先应用场景：就是在

我们需要重复使用某个对象的时候，如果我们重复地使用new创建这个对象的话，这样我们在内存就需要多次地去申请内存空间了，这样可能会出现内存使用越来越多的情况，这样的问题是非常严重，然而享元模式可以解决这个问题，具体定义：运用共享技术有效地支持大量细粒度的对象。享元模式可以避免大量相似类的开销，在软件开发中如果需要生成大量细粒度的类实例来表示数据，如果这些实例除了几个参数外基本上都是相同的，这时候就可以使用享元模式来大幅度减少需要实例化类的数量。如果能把这些参数（指的这些类实例不同的参数）移动类实例外面，在方法调用时将他们传递进来，这样就可以通过共享大幅度地减少单个实例的数目。（这个也是享元模式的实现要领）,然而我们把类实例外面的参数称为享元对象的外部状态，把在享元对象内部定义称为内部状态。具体享元对象的内部状态与外部状态的定义为：
内部状态：在享元对象的内部并且不会随着环境的改变而改变的共享部分

外部状态：随环境改变而改变的，不可以共享的状态。

上热菜：

      // 定义外部状态，例如字母的位置等信息

            int externalstate = 10;

            // 初始化享元工厂

            FlyweightFactory factory = new FlyweightFactory();

            // 判断是否已经创建了字母A，如果已经创建就直接使用创建的对象A

            Flyweight fa = factory.GetFlyweight("A");

            if (fa != null)

            {

                // 把外部状态作为享元对象的方法调用参数

                fa.Operation(--externalstate);

            }

            // 判断是否已经创建了字母B

            Flyweight fb = factory.GetFlyweight("B");

            if (fb != null)

            {

                fb.Operation(--externalstate);

            }

            // 判断是否已经创建了字母C

            Flyweight fc = factory.GetFlyweight("C");

            if (fc != null)

            {

                fc.Operation(--externalstate);

            }

            // 判断是否已经创建了字母D

            Flyweight fd = factory.GetFlyweight("D");

            if (fd != null)

            {

                fd.Operation(--externalstate);

            }

            else

            {                   

                Console.WriteLine("驻留池中不存在字符串D");

                // 这时候就需要创建一个对象并放入驻留池中

                ConcreteFlyweight d = new ConcreteFlyweight("D");

                factory.flyweights.Add("D", d);

            }

            Console.Read();

        }

   

        /// <summary>

        /// 享元工厂，负责创建和管理享元对象

        /// </summary>

        public class FlyweightFactory

        {

            // 最好使用泛型Dictionary<string,Flyweighy>

            //public Dictionary<string, Flyweight> flyweights = new Dictionary<string, Flyweight>();

            public Hashtable flyweights = new Hashtable();

            public FlyweightFactory()

            {

                flyweights.Add("A", new ConcreteFlyweight("A"));

                flyweights.Add("B", new ConcreteFlyweight("B"));

                flyweights.Add("C", new ConcreteFlyweight("C"));

            }

            public Flyweight GetFlyweight(string key)

            {

                // 更好的实现如下

                //Flyweight flyweight = flyweights[key] as Flyweight;

                //if (flyweight == null)

                //{

                //    Console.WriteLine("驻留池中不存在字符串" + key);

                //    flyweight = new ConcreteFlyweight(key);

                //}

                //return flyweight;

                return flyweights[key] as Flyweight;

            }

        }

        /// <summary>

        ///  抽象享元类，提供具体享元类具有的方法

        /// </summary>

        public abstract class Flyweight

        {

            public abstract void Operation(int extrinsicstate);

        }

        // 具体的享元对象，这样我们不把每个字母设计成一个单独的类了，而是作为把共享的字母作为享元对象的内部状态

        public class ConcreteFlyweight : Flyweight

        {

            // 内部状态

            private string intrinsicstate;

            // 构造函数

            public ConcreteFlyweight(string innerState)

            {

                this.intrinsicstate = innerState;

            }

            /// <summary>

            /// 享元类的实例方法

            /// </summary>

            /// <param name="extrinsicstate">外部状态</param>

            public override void Operation(int extrinsicstate)

            {

                Console.WriteLine("具体实现类: intrinsicstate {0}, extrinsicstate {1}", intrinsicstate, extrinsicstate);

            }

        }

运行结果如下：