享元模式

享元模式： 运用共享技术有效的支持大量细粒度的对象

UML结构图：

基本代码：

  public abstract class Flyweight
    {
        public abstract void Operation(int extrinsicstate);
    }


    public class ConcreteFlyweight : Flyweight 
    {
        public override void Operation(int extrinsicstate)
        {
            Console.WriteLine("具体Flyweight:"+extrinsicstate);
        }    
    }

    public class UnsharedConcreteFlyweight : Flyweight 
    {
        public override void Operation(int extrinsicstate)
        {
            Console.WriteLine("不共享的具体Flyweight:" + extrinsicstate);
        }
    }

    //享元工厂
    public class FlyweightFactory 
    {
        private Hashtable flyweights = new Hashtable();

        //初始化3个实例
        public FlyweightFactory() 
        {
            flyweights.Add("x",new ConcreteFlyweight());
            flyweights.Add("y",new ConcreteFlyweight());
            flyweights.Add("z",new ConcreteFlyweight());
        }

        public Flyweight GetFlyweight(string key) 
        {
            return (Flyweight)flyweights[key];
        }
    }

客户端调用：

   int extrinsicstate = 22;
            FlyweightFactory f = new FlyweightFactory();

            Flyweight fx = f.GetFlyweight("x");
            fx.Operation(--extrinsicstate);

            Flyweight fy = f.GetFlyweight("y");
            fy.Operation(--extrinsicstate);

            Flyweight fz = f.GetFlyweight("z");
            fz.Operation(--extrinsicstate);

            Flyweight uf = new UnsharedConcreteFlyweight();
            uf.Operation(--extrinsicstate);

显示：

听题：
构建一个由不同用户使用的通用网站

代码：

   //用户类
    public class User
    {
        private string name;
        public User(string name) 
        {
            this.name = name;
        }

        public string Name 
        {
            get { return name; }
        }
    }
    //网站抽象类
    public abstract class WebSite 
    {
        public abstract void Use(User user);
    }

    //网站具体类
    public  class ConcreteWebSite : WebSite 
    {
        private string name = "";
        public ConcreteWebSite(string name) 
        {
            this.name = name;
        }

        public override void Use(User user)
        {
            Console.WriteLine("网站分类："+name+"用户:"+user.Name);
        }
    }

    //网站工厂类
    public class WebSiteFactory 
    {
        private Hashtable flyweights = new Hashtable();

        //获得网站分类
        public WebSite GetWebSiteCategory(string key) 
        {
            if (!flyweights.ContainsKey(key)) 
            {
                flyweights.Add(key,new ConcreteWebSite(key));
            }
            return (WebSite)flyweights[key];
        }

        public int GetWebSiteCount() 
        {
            return flyweights.Count;
        }
    }

调用客户代码：

    WebSiteFactory f = new WebSiteFactory();

            WebSite fx = f.GetWebSiteCategory("x");
            fx.Use(new User("小菜"));

            WebSite fy = f.GetWebSiteCategory("y");
            fy.Use(new User("大鸟"));

            WebSite fz = f.GetWebSiteCategory("z");
            fz.Use(new User("娇娇"));

            Console.WriteLine("得到网站分类总数：{0}", f.GetWebSiteCount());

显示：

优缺点及适用场景

优点：

降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

缺点：

1）为了使对象可以共享，需要将对象的一些状态外部化，增加了系统复杂度

2）将享元对象状态外部化，使得读取外部状态的运行时间稍微变长。

适用场景：

系统中需要大量的细粒度对象，同时这些对象耗费大量的内存，并且对象的状态大部分可以外部化，此时使用享元模式是没有错的。