c#设计模式-结构型模式-6.享元模式

Posted 2021-05-29 mr.chenyuelin

享元模式：共享之前创建过的对象，对象复用

看例子吧

例子，就是比如我需要20个上兵，一半是陆军，一半是海军，我们不是new20个对象，而是如果创建的是陆军的对象，如果之前创建过陆军对象，就不需要重新new了，直接从list中取就好了，遇到新的兵种时，再加到list里，然后下一次就不需要new了，重复这个过程

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 享元模式
{
    public enum SoldierType
    {
        Normal,
        Water
    }

    public abstract class Soldier
    {
        public string Name { get; private set; }

        protected Soldier(string name)
        {
            this.Name = name;
        }

        public Weapen WeapenInstance { get; set; }
        public abstract void Fight();
    }
    public sealed class NormalSoldier : Soldier
    {
        public NormalSoldier(string name) : base(name) { }
        public override void Fight()
        {
            WeapenInstance.Fire("士兵：" + Name + "在陆地执行任务");
        }
    }
    public sealed class WaterSoldier : Soldier
    {
        public WaterSoldier(string name) : base(name) { }
        public override void Fight()
        {
            WeapenInstance.Fire("士兵：" + Name + "在海中执行任务");
        }
    }
    public abstract class Weapen
    {
        public abstract void Fire(string jobName);
    }
    public sealed class AK47 : Weapen
    {
        public override void Fire(string jobName)
        {
            Console.WriteLine(jobName);
        }
    }
	//核心
    public sealed class SolidierFactory
    {
        private static List<Soldier> soldiers;
        static SolidierFactory()
        {
            soldiers = new List<Soldier>();
        }
        Soldier mySoldier = null;

        public Soldier GetSoldier(string name,Weapen weapen,SoldierType soldierType)
        {
            foreach (Soldier soldier in soldiers)
            {
                //如果当前list出现过，则无需创建对象直接返回
                if (string.Compare(soldier.Name, name, true) == 0)
                {
                    mySoldier = soldier;
                    return mySoldier;
                }
            }
            switch (soldierType)
            {
                case SoldierType.Normal:
                    mySoldier = new NormalSoldier(name);
                    break;
                case SoldierType.Water:
                    mySoldier = new WaterSoldier(name);
                    break;              
            }
            mySoldier.WeapenInstance = weapen;
            soldiers.Add(mySoldier);
            return mySoldier;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            SolidierFactory solidierFactory = new SolidierFactory();
            AK47 aK47 = new AK47();
            for (int i = 0; i < 20; i++)
            {
                Soldier soldier = null;
                if (i <= 10)
                    soldier = solidierFactory.GetSoldier("士兵" + (i + 1), aK47, SoldierType.Normal);
                else
                    soldier = solidierFactory.GetSoldier("士兵" + (i + 1), aK47, SoldierType.Water);
                soldier.Fight();
            }
            Console.Read();
        }
    }
}

享元模式的使用场景：

当系统中大量使用某些相同或者相似的对象，这些对象要耗费大量的内存，并且这些对象剔除外部状态后可以通过一个对象来替代，这时可以考虑使用享元模式。在软件系统中享元模式大量用于各种池技术，如数据库连接对象池，字符串缓存池，HttpApplication池等。

享元模式的优点：

通过对象的复用减少了对象的数量，节省内存。

享元模式的缺点：

需要分离对象的外部状态和内部状态，使用不当会引起线程安全问题，提高了系统的复杂度。