简单工厂

简单工厂

简单工厂模式的工厂类一般是使用静态方法，通过接收的参数不同来返回不同的对象实例。不修改代码的话，是无法扩展的

优点：客户端可以免除直接创建产品对象的责任，而仅仅是“消费”产品。简单工厂模式通过这种做法实现了对责任的分割

缺点：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了

普通方法调用

    /// <summary>
    /// 玩家
    /// </summary>
    public class Player
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public void PlayHuman(Human human)
        {
            Console.WriteLine("******************************");
            Console.WriteLine("This is {0} Play War3.{1}", this.Name, human.GetType().Name);
            human.ShowKing();
        }

        public void PlayORC(ORC orc)
        {
            Console.WriteLine("******************************");
            Console.WriteLine("This is {0} Play War3.{1}", this.Name, orc.GetType().Name);
            orc.ShowKing();
        }

        public void PlayORC(Undead undead)
        {
            Console.WriteLine("******************************");
            Console.WriteLine("This is {0} Play War3.{1}", this.Name, undead.GetType().Name);
            undead.ShowKing();
        }

        /// <summary>
        /// 面向抽象
        /// </summary>
        /// <param name="race"></param>
        public void PlayWar3(IRace race)
        {
            Console.WriteLine("******************************");
            Console.WriteLine("This is {0} Play War3.{1}", this.Name, race.GetType().Name);
            race.ShowKing();
        }
        

    }

    /// <summary>
    /// War3种族之一
    /// </summary>
    public class Human : IRace
    {
        public Human(int id, DateTime dateTime, string reamrk)
        { }
        public Human()
        { }

        public void ShowKing()
        {
            Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Sky");
        }
    }

    /// <summary>
    /// War3种族之一
    /// </summary>
    public class ORC : IRace
    {
        public void ShowKing()
        {
            Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Grubby");
        }
    }

    /// <summary>
    /// War3种族之一
    /// </summary>
    public class Undead : IRace
    {
        public void ShowKing()
        {
            Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "GoStop");
        }
    }

    /// <summary>
    /// War3种族之一
    /// </summary>
    public class NE : IRace
    {
        public void ShowKing()
        {
            Console.WriteLine("The King of {0} is {1}", this.GetType().Name, "Moon");
        }
    }

                Player player = new Player()
                {
                    Id = 123,
                    Name = "候鸟"
                };
                #region
                {
                    Human human = new Human();
                    player.PlayHuman(human);
                }
                {
                    ORC orc = new ORC();
                    player.PlayORC(orc);
                }
                {
                    Undead undead = new Undead();
                    player.PlayWar3(undead);
                }
                {
                    NE ne = new NE();
                    player.PlayWar3(ne);
                }
                #endregion

优化第一步=> 面向对象 => 封装、继承=> 几个种族分别继承接口

    public interface IRace
    {
        /// <summary>
        /// show出王者
        /// </summary>
        void ShowKing();
    }

               {
                    Human human = new Human();//1 到处都是细节
                    player.PlayWar3(human);
                }
                {
                    IRace human = new Human();//2 左边是抽象  右边是细节
                    player.PlayWar3(human);
                }

想去细节  想去掉什么东西，咱们就封装一下 转移一下

    public enum RaceType
    {
        Human,
        Undead,
        ORC,
        NE
    }

        /// <summary>
        /// 细节没有消失  只是转移
        /// 转移了矛盾，并没有消除矛盾
        /// 
        /// 集中了矛盾
        /// </summary>
        /// <param name="raceType"></param>
        /// <returns></returns>
        public static IRace CreateRace(RaceType raceType)
        {
            IRace iRace = null;
            switch (raceType)
            {
                case RaceType.Human:
                    iRace = new Human();
                    break;
                case RaceType.Undead:
                    iRace = new Undead();
                    break;
                case RaceType.ORC:
                    iRace = new ORC();
                    break;
                case RaceType.NE:
                    iRace = new NE();
                    break;
                //增加一个分支
                default:
                    throw new Exception("wrong raceType");
            }
            return iRace;
        }

前端调用

               {
                    IRace human = ObjectFactory.CreateRace(RaceType.Human); //new IRace();// //new Human();//3 没有细节  细节被转移
                    player.PlayWar3(human);
                }
                {
                    IRace undead = ObjectFactory.CreateRace(RaceType.Undead); //new Human();//3 没有细节 细节被转移
                    player.PlayWar3(undead);
                }

这样简单工厂就出来了，但是这种方法并没有取消细节，而是集中了矛盾，每改一个类都有可能需要修改CreateRace方法，这种方法违反了低耦合的原则

有什么方法可以优化一下吗，

怎么同时生成两个不同的种族？
一个方法 不要参数 可能创建不同类型的实例吗
那只能传参数 传一个human 结果可能是Human 也可以是Undead

把传递的参数 放入到配置文件 可配置的

        private static string IRacTypeConfig = ConfigurationManager.AppSettings["IRacTypeConfig"];//IRacTypeConfig+参数
        public static IRace CreateRaceConfig()
        {
            RaceType raceType = (RaceType)Enum.Parse(typeof(RaceType), IRacTypeConfig);
            return CreateRace(raceType);
        }

前端调用

Console.WriteLine("*********************CreateRaceConfig*****************");
                {
                    IRace undead = ObjectFactory.CreateRaceConfig(); //new Human();//4 可配置
                    player.PlayWar3(undead);
                }

如果拓展了新种族

        //1 方法增加个参数
        //2 给不同的参数，配置不同的IRacTypeConfigReflection

        //多方法是不对的，因为没法扩展新种族
        //泛型也不对  泛型需要上端知道具体类型

        private static string IRacTypeConfigReflection = ConfigurationManager.AppSettings["IRacTypeConfigReflection"];
        private static string DllName = IRacTypeConfigReflection.Split(',')[1];
        private static string TypeName = IRacTypeConfigReflection.Split(',')[0];
        /// <summary>
        /// ioc的雏形  可配置可扩展的
        /// </summary>
        /// <returns></returns>
        public static IRace CreateRaceConfigReflection()
        {
            Assembly assembly = Assembly.Load(DllName);
            Type type = assembly.GetType(TypeName);
            IRace iRace = Activator.CreateInstance(type) as IRace;

            return iRace;
        }

前端调用

               {
                    IRace undead = ObjectFactory.CreateRaceConfigReflection(); //5 可配置可扩展
                    player.PlayWar3(undead);
                }