今天接着讲上一节的创建性模式中的享元模式(Flyweight Pattern)、代理模式(Proxy Pattern)。

先介绍一下享元模式(Flyweight Pattern)的定义和在什么情况下使用。
使用情况：在对象数量比较多时，导致运行代价提高时才使用；
定义：针对对象数量多，运用共享技术有效的支持大量细粒度对象。
下面来分析一下《设计模式》一书中的享元模式的实例：

namespace Flyweight.DesignPattern
{
      using System;
      using System.Collections;

      class FlyweightFactory 
          {
               private ArrayList pool = new ArrayList();
               public FlyweightFactory()
                  {
                      pool.Add(new ConcreteEvenFlyweight());  
                      pool.Add(new ConcreteUnevenFlyweight());   
                  }

              public Flyweight GetFlyweight(int key)                          //返回ArrayList中的数组值
                 {
                     int i = key % 2;
                     return((Flyweight)pool[i]); 
                }
         }

    abstract class Flyweight                                                             //声明享元抽象类
        {
            abstract public void DoOperation(int extrinsicState);      //声明抽象方法
        }

    class UnsharedConcreteFlyweight : Flyweight                         //定义Flyweight派生类
       {
           override public void DoOperation(int extrinsicState)       //覆写DoOperation方法
               {
   
               }
       }

    class ConcreteEvenFlyweight : Flyweight                                //定义Flyweight派生类
        {
            override public void DoOperation(int extrinsicState)      //覆写父类中的方法，并实例化
                 {
                       Console.WriteLine("In ConcreteEvenFlyweight.DoOperation: {0}", extrinsicState);      
                 }
         }

    class ConcreteUnevenFlyweight : Flyweight                             //定义Flyweight派生类
        {
            override public void DoOperation(int extrinsicState)       //覆写父类中的方法实例化
                 {
                      Console.WriteLine("In ConcreteUnevenFlyweight.DoOperation: {0}", extrinsicState);   
                 } 
        }

    public class Client
    {
        public static int Main(string[] args)
        {
            int[] data = {1,2,3,4,5,6,7,8};
            FlyweightFactory f = new FlyweightFactory();        //声明享元工厂对象
            int extrinsicState = 3;
            foreach (int i in data)                                                 //遍历data数组
               {
                    Flyweight flyweight = f.GetFlyweight(i);          //将处理过的值赋给flyweight对象
                    flyweight.DoOperation(extrinsicState);           //调用DoOperation方法
               }
               return 0;
        }
    }
}

接下来了解一下代理模式(Proxy Pattern)的定义和在什么情况下使用。
定义：代理(Proxy)通常包含和将要使用的对象同样的方法，一旦开始使用这个对象，这些方法将通过代理(Proxy)传递给实际的对象。
使用情况：一个对象，比如一幅很大的图像，需要载入的时间很长，需要很长时间才可以完成的计算结果，并且需要在它计算过程中显示中间结果。这是一个需要载入和显示一幅很大的图像的程序，当程序启动时，就必须确定要显示的图像，但是实际的图像只能在完全载入后才可以显示！这时我们就可以使用代理模式(Proxy)。