以共享的方式高效的支持大量的细粒度对象。
享元对象能作到共享的关键是区分内蕴状态和外蕴状态，内蕴状态存储在享元对象内部不会随环境的改变有所不同因此享元的
内蕴状态可以共享。外蕴状态随环境的改变而改变，不可以共享必须由使用的客户保存，并在享元对象创建后在需要的时候传
入到享元内部，外蕴状态和内蕴状态是相互独立的。
单纯享元模式中所有的享元对象都是可以共享的。
单纯享元模式涉及的角色如下：
抽象享元角色：所有具体享元的超类
具体享元：如果有内蕴状态的话必须为内蕴状态提供存储空间。
享元工厂：负责创建和管理享元对象，此角色必须保证享元对象可以被适当的共享，当客户调用一个享元对象的时候享元工厂
检查系统中是否有符合要求的对象，如果有工厂将提供这个享元对象如果没有工厂将创建一个合适的享元对象。一般来说整个
系统享元工厂只有一个因此可以使用单例模式。
客户端：维护对所有享元对象的引用，需要存储所有享元对象的外蕴状态。

复合享元模式
将一些单纯享元使用合成模式加以复合形成复合享元对象，这种复合享元对象本身不能共享但它们分解成单纯享元对象而后者
可以共享。

复合享元涉及的角色如下：
1、抽象享元角色：抽象享元的接口使享元的共享成为可能，但是并不强制子类共享，因此并非所有的享元对象都是可以共享的
2、具体享元：又叫单纯具体享元，因为复合享元是由单纯具体享元复合而成的。
3、复合享元：又叫不可共享的享元对象。
4、享元工厂
5、客户端

namespace DesignPattern.Flyweight
{
    public abstract class AbstractFlyweight
    {
        public abstract void Operation(string extrinsicState);
    }

    public class ConcreteFlyweight : AbstractFlyweight
    {
        
        private char intrinsicState;
        /**//// <summary>
        /// 构造函数内蕴状态作为参数传入
        /// </summary>
        /// <param name="intrinsicState"></param>
        public ConcreteFlyweight(char intrinsicState)
        {
            this.intrinsicState=intrinsicState;
        }

        /**//// <summary>
        /// 外蕴状态作为参数传入，改变方法的行为，但不改变对象的内蕴状态
        /// </summary>
        /// <param name="extrinsicState"></param>
        public override void Operation(string extrinsicState)
        {
            Console.WriteLine("intrinsic state {0},extrinsic state {1}",this.intrinsicState,extrinsicState);
        }
    }

    public class FlyweightFactory
    {
        private Hashtable files;

        public FlyweightFactory()
        {
            files=new Hashtable();
        }

        public ConcreteFlyweight GetFlyweight(char state)
        {
            if(files.Contains(state))
            {
                return (ConcreteFlyweight)files[state];
            }
            else
            {
                ConcreteFlyweight fly=new ConcreteFlyweight(state);
                files.Add(state,fly);
                return fly;
            }
        }

        /**//// <summary>
        /// 辅助方法检查享元对象的所有实例
        /// </summary>
        public void CheckFlyweight()
        {
            foreach(char key in files.Keys)
                Console.WriteLine(key);
        }
    }

    public class Client
    {
        /**//// <summary>
        /// 使用享元模式的时候首先创建享元工厂对象，然后向享元工厂对象要求具有某个内蕴状态
        /// 的享元。
        /// </summary>
        public static void Main()
        {
                FlyweightFactory ff=new FlyweightFactory();
                AbstractFlyweight f1=ff.GetFlyweight('A');
                AbstractFlyweight f2=ff.GetFlyweight('B');
                AbstractFlyweight f3=ff.GetFlyweight('A');
                f1.Operation("ExtrinsicState 1");
                f2.Operation("ExtrinsicState 2");
                f3.Operation("ExtrinsicState 3");
                ff.CheckFlyweight();
        }
    }
}