设计模式-----基于反射工厂模式

最近在学设计模式。在此记录每次学习

工厂模式是我们最常听到和用到的设计模式之一。之前也用到过，但是每次没有好好整理。

工厂模式的好处网上都很多解释。最主要减少程序耦合度，方便维护，扩展等等。

当一个程序越大，出现新的需求时，维护性，可扩展性就会显得越重要。

工厂模式：一般创建子类对象赋值基类或接口，但是无论是接口还是基类原理都是多态。继承在工厂模式也起了很重要作用，代码封装。

假设有一个公司要管理工资发放

公司里所有的人都是员工（Employee），应该有个Employee，里面应该有基本信息，和最重要工资计算方法

public abstract class Employee
{
        public int JobNumber { get; set; }
        public string Name { get; set; }

        public Employee(int number, string name)
        {
            this.JobNumber = number;
            this.Name = name;
        }
        public abstract double CalcularSalar();
}

有个项目经理，工资计算方式：5000(基本工资) + 项目奖金 。 项目经理也是员工，所以继承员工类

public class Manager : Employee
{
        private readonly double BASESALE = 0.0;
        private readonly double REWARDSALE = 0.0;

        public Manager(double baseSale, int number, string name)
            : base(number, name)
        {
            this.BASESALE = baseSale;
            this.REWARDSALE = 2000;
        }
        public override double CalcularSalar()
        {
            return this.BASESALE + this.REWARDSALE;
        }
}

也有程序员，工资计算方式：3000(基本奖金)。同理程序员也应该继承员工类

class Programer : Employee
 {
        private readonly double BASESALE = 0.0;
        public Programer(double baseSale, int number, string name)
            : base(number, name)
        {
            this.BASESALE = baseSale;
        }
        public override double CalcularSalar()
        {
            return this.BASESALE;
        }
 }

当然还有最重要工厂类

public class Factory
{
        public static object CreateObject(string assembly,string objName,params object[] args)
        {
            try
            {
                Assembly asm = Assembly.Load(assembly);
                if (asm == null) return null;

                string fullName = assembly + "." + objName;

                Type type = asm.GetType(fullName);
                Object obj = Activator.CreateInstance(type, args);

                if (obj == null) return null;
                return obj;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLog("[Factory].CreateObject(string objName)", ex.Message);
                return null;
            }
        }
 }

所有东西弄好，就到发工资

一般我们是

Manager manager = new Manager(5000, 2000, 1, "Jack");
manager.CalcularSalar();

Programer programer = new Programer(3000, 2, "Mike");

programer.CalcularSalar();

这样虽然是通俗易懂，但是不易维护，不易扩展，当出现新员工时，改动较大

工厂模式：

object[] paramers = new object[3];
paramers[0] = double.Parse(this.cmbBaseSale.Text);
paramers[1] = int.Parse(this.cmbJobNumber.Text);
paramers[2] = this.cmbName.Text;

Employee employee = Factory.CreateObject(GlobalValue.Model, this.cmbType.Text, paramers) as Employee;

MessageBox.Show(employee.CalcularSalar().ToString());

当公司发展需要一个测试人员，要程序员写一个测试人员发工资计算（基本工资 2500）

项目经理不可能把整个项目给程序员修改（万一程序员修改程序员发工资方式，每个月给自己+1000）

这时工厂模式发挥作用，项目经理只要告诉你有一个Employee的类，你去继承它实现测试人员类

很快可以写出

public class Tester:Employee
  {
        private readonly double BASESALE = 0.0;
        public Tester(double baseSale, int number, string name)
            : base(number, name)
        {
            this.BASESALE = baseSale;
        }
        public override double CalcularSalar()
        {
            return this.BASESALE;
        }
 }

只需要加入这个类，程序就能发测试人员工资