享元模式（25）

今天我们来讲一下享元模式。

我们在工作之余可能会接一些私活，比如，帮人开发一个网站，帮人开发一个私人博客。随着私活的增多，会发现，有很多项目是有相同之处的，比如，帮人开发一个网站，你会发现，之前做的一些网站的代码单元是可以公共的。所以，即便是有很多的私活，我们不要盲目的去做一些项目，我们要善于发现，善于总结，这样会大大提高我们的效率。

我们将上述场景用代码体现一下就如同下面代码：

    /// <summary>
    /// 网站类
    /// </summary>
    class WebSite
    {
        private string name = "";

        public WebSite(string name)
        {
            this.name = name;
        }

        public void Use()
        {
            Console.WriteLine($"网站分类：{name}");
        }
    }

客户端调用：

        public static void Main()
        {
            WebSite fx = new WebSite("门户网站");
            fx.Use();

            WebSite fy = new WebSite("门户网站");
            fy.Use();

            WebSite fz = new WebSite("门户网站");
            fz.Use();

            WebSite fl = new WebSite("个人博客");
            fl.Use();

            WebSite fm = new WebSite("个人博客");
            fm.Use();

            WebSite fn = new WebSite("个人博客");
            fn.Use();

            Console.ReadKey();
        }

在弄清楚如何共享代码之前，我们先来谈一下今天我们要讲的设计模式——享元模式。

享元模式，运用共享技术有效地支持大量细粒度地对象，所有具体享元类地超类或接口，通过这个接口，可以接受并作用于外部状态。

我们再来看一下它的结构代码：

    //所有具体享元类地超类或接口，通过这个接口，可以接受并作用于外部状态
    abstract class Flyweight
    {
        public abstract void Operation(int extrinsicstate);
    }
    //继承Flyweight实现Flyweight接口
    class ConcreteFlyweight : Flyweight
    {
        public override void Operation(int extrinsicstate)
        {
            Console.WriteLine($"具体Flyweight：{extrinsicstate}");
        }
    }
    //不需要共享Flyweight子类，因为Flyweight接口共享成为可能，但它并不强制共享
    class UnsharedConcreteFlyweight : Flyweight
    {
        public override void Operation(int extrinsicstate)
        {
            Console.WriteLine($"不共享的具体Flyweight：{extrinsicstate}");
        }
    }
    //享元工厂，用来创建并管理Flyweight对象，它主要是用来确保合理的
    //共享Flyweight，当用户请求一个Flyweight时，享元工厂对象提供一个
    //已经创建的实例或者创建一个（如果不存在的话）
    class FlyweighFactory
    {
        private Hashtable flyweights = new Hashtable();
        /// <summary>
        /// 初始化工厂时，先生成三个实例
        /// </summary>
        public FlyweighFactory()
        {
            flyweights.Add("X", new ConcreteFlyweight());
            flyweights.Add("Y", new ConcreteFlyweight());
            flyweights.Add("Z", new ConcreteFlyweight());
        }
        //根据客户端请求，获得已生成的实例
        public Flyweight GetFlyweight(string key)
        {
            return ((Flyweight) flyweights[key]);
        }
    }

客户端：

        public static void Main()
        {
            //代码外部状态
            int extrinsicstate = 22;
            FlyweighFactory f = new FlyweighFactory();

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

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

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

            UnsharedConcreteFlyweight uf = new UnsharedConcreteFlyweight();

            uf.Operation(--extrinsicstate);

            Console.ReadKey();
        }

好，我们用享元模式将我们案例中的代码来重构一下：

    //网站抽象类
    abstract class WebSite
    {
        public abstract void Use();
    }
    //具体网站类
    class ConcreteWebSite : WebSite
    {
        private string name = "";

        public ConcreteWebSite(string name)
        {
            this.name = name;
        }
        public override void Use()
        {
            Console.WriteLine($"网站分类{name}");
        }
    }
    //网站工厂
    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];
            }
            else
            {
                return (WebSite)flyweights[key];
            }
        }
        //获得网站分类总数
        public int GetWebSiteCount()
        {
            return flyweights.Count;
        }
    }

客户端：

        public static void Main()
        {
            WebSiteFactory f = new WebSiteFactory();

            //实例化 门户网站 对象
            WebSite fx = f.GetWebSiteCategory("门户网站");
            fx.Use();

            //共享上方生成的对象，不再实例化
            WebSite fy = f.GetWebSiteCategory("门户网站");
            fy.Use();
            //共享上方生成的对象，不再实例化
            WebSite fz = f.GetWebSiteCategory("门户网站");
            fz.Use();

            WebSite fl = f.GetWebSiteCategory("个人博客");
            fl.Use();

            WebSite fm = f.GetWebSiteCategory("个人博客");
            fm.Use();

            WebSite fn = f.GetWebSiteCategory("个人博客");
            fn.Use();

            //统计实例化个数，结果应该为2
            Console.WriteLine($"网站分类总数为{f.GetWebSiteCount()}");
            Console.ReadKey();
        }

这样写基本体现了享元模式享元模式，但是我们在做项目的过程中，即便是再相似的项目，面对不同企业，也会有不同的地方。

好，今天的享元模式就讲到这里了，下一篇我们讲 解释器模式

---

本系列将持续更新，喜欢的小伙伴可以点一下关注和推荐，谢谢大家的支持