C#设计模式之【结构型设计模式：享元模式】

一.享元模式简述

   享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。
   享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。ThreadPool 线程池 与数据库连接池 都有使用享元模式。

   UML图：（）

二.代码示例

   假如有三个汽车类：奥迪，宝马，奔驰，这几个类的对象创建特别消耗资源。这个时候我们可以使用享元模式。

   基础汽车类：

    /// <summary>
    /// 汽车接口
    /// </summary>
   public interface ICar
    {
        void ShowCar();
    }


    /// <summary>
    /// 奥迪
    /// </summary>
    public class AudiCar : ICar
    {
        public AudiCar()
        {
            Thread.Sleep(3000);//创建对象耗时
            Console.WriteLine("奥迪对象被创建");
        }

        public void ShowCar()
        {
            Console.WriteLine("show 奥迪");
        }
    }


    /// <summary>
    /// 宝马
    /// </summary>
    public class BMWCar : ICar
    {
        public BMWCar()
        {
            Thread.Sleep(3000);//创建对象耗时
            Console.WriteLine("宝马对象被创建");
        }

        public void ShowCar()
        {
            Console.WriteLine("show 宝马");
        }
    }


    /// <summary>
    /// 奔驰
    /// </summary>
    public class BenzCar : ICar
    {
        public BenzCar()
        {
            Thread.Sleep(3000);//创建对象耗时
            Console.WriteLine("奔驰对象被创建");
        }

        public void ShowCar()
        {
            Console.WriteLine("show 奔驰");
        }
    }

   享元工厂类：

    /// <summary>
    /// 享元工厂类
    /// </summary>
    public class FlyweightFactory
    {
        /// <summary>
        /// 准备个容器，数据复用
        /// </summary>
        private static Dictionary<string, ICar> FlyweightFactoryDictionary = new Dictionary<string, ICar>();
        private readonly static object FlyweightFactoryLock = new object();

        public static ICar CreateCar(string carType)
        {
            if (!FlyweightFactoryDictionary.ContainsKey(carType))
            {
                lock (FlyweightFactoryLock)//加锁
                {
                    if (!FlyweightFactoryDictionary.ContainsKey(carType))
                    {
                        ICar car = null;
                        switch (carType)
                        {
                            case "Audi":
                                car = new AudiCar();
                                break;
                            case "BMW":
                                car = new BMWCar();
                                break;
                            case "Benz":
                                car = new BenzCar();
                                break;
                                throw new Exception("wrong carType!");
                        }
                        FlyweightFactoryDictionary.Add(carType, car);
                    }
                }
            }
            return FlyweightFactoryDictionary[carType];
        }
    }

   运行结果：

三.总结

意图： 运用共享技术有效地支持大量细粒度的对象。

主要解决： 在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。

优点： 大大减少对象的创建，降低系统的内存，使效率提高。

缺点： 提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

使用场景： 1、系统有大量相似对象。 2、需要缓冲池的场景。

注意事项： 1、注意划分外部状态和内部状态，否则可能会引起线程安全问题。 2、这些类必须有一个工厂对象加以控制。3.和单例模式有点像

和单例模式异同：
   享元模式可以再次创建对象，也可以取缓存对象
   单例模式则是严格控制单个进程中只有一个实例对象
   它们的目的是一样的，至少就内存的开销问题这点，两者是相同的。而享元模式可以看成是单例的一个扩展。