抽象工厂模式

简单工厂模式：

                  有点：所有的产品都在一个工厂里创建。实现了，消费和生产的分离，

                  缺点：是不符合高内聚的原则，无法我缝扩展。

工厂模式：

              优点：实现了高内聚就的原则。所有的工厂职责单一，可以无缝扩展。

              缺点：工厂类太多了，维护麻烦。

抽象工厂模式：工厂不在生成单一的对象，而是生成有依赖关系的多个子对象。抽象工厂模式集合了，前两者的优点，屏蔽了一些缺点。

详情可以看他的这边文章：http://www.cnblogs.com/Terrylee/archive/2005/12/13/295965.html

虚拟案例

中国企业需要一项简单的财务计算：每月月底，财务人员要计算员工的工资。

员工的工资 = (基本工资 + 奖金 - 个人所得税)。这是一个放之四海皆准的运算法则。

为了简化系统，我们假设员工基本工资总是4000美金。

中国企业奖金和个人所得税的计算规则是:

         奖金 = 基本工资(4000) * 10%

         个人所得税 = (基本工资 + 奖金) * 40%

我们现在要为此构建一个软件系统（代号叫Softo），满足中国企业的需求。

案例分析

奖金(Bonus)、个人所得税(Tax)的计算是Softo系统的业务规则(Service)。

工资的计算(Calculator)则调用业务规则(Service)来计算员工的实际工资。

工资的计算作为业务规则的前端(或者客户端Client)将提供给最终使用该系统的用户(财务人员)使用。

根据他的文章自己写的实现

先是服务端代码：

 抽象工厂和他的子类

代码

  /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class AbstractFactory
    {
        public static AbstractFactory GetInstance()
        {
            string factoryname = Contant.Src_FactoryName;
            AbstractFactory instance;
            if (factoryname != null) {
                instance = (AbstractFactory)Assembly.Load("AbstractFactory").CreateInstance(factoryname);
            }
            else
            {
                instance= null;
            }
            return instance;
        }

        public abstract Tax CreateTax();
        public abstract Bonus CreateBonus();
    }

抽象产品A类

  /// <summary>
    /// 抽象工厂子类 计算奖金
    /// </summary>
    public abstract class Bonus
    {
        /// <summary>
        /// 计算奖金
        /// </summary>
        /// <returns></returns>
        public abstract double Calculate();
    }

抽象产品B类

 /// <summary>
    ///  抽象工厂子类：计算个人所得税的类
    /// </summary>
    public abstract class Tax
    {
        public abstract double Calculate();

    }

根据上面的抽象工厂去实际生产产品

 

 实现抽象工厂ChineseSalaryFactory类

/// <summary>
    /// 中国员工的工厂类
    /// </summary>
    public class ChineseSalaryFactory:AbstractFactory.Server.AbstractFactory
    {
        public override Tax CreateTax()
        {
           return new ChineseTax();
        }

        public override Bonus CreateBonus()
        {
            return new ChineseBonus();
        }
    }

实现产品A 

    /// 子类创建计算中国奖金的类
    /// </summary>
    public class ChineseBonus : Bonus
    {
        public override double Calculate()
        {
            return Contant.BaseSalary * 0.1;
        }
    }

实现产品B

    /// <summary>
    ///创建计算中国员工个人所得税子类
    /// </summary>
    public class ChineseTax : Tax
    {
        public override double Calculate()
        {
            return (Contant.BaseSalary + Contant.BaseSalary * 0.1) * 0.4;
        }
    }

第二个 实现抽象工厂AmericaSalaryFactory类

 public class AmericaSalaryFactory : Server.AbstractFactory
    {
        public override Server.Tax CreateTax()
        {
            return new AmericaTax();
        }

        public override Server.Bonus CreateBonus()
        {
            return new AmericaBonus();
        }
    }

实现产品A

    public class AmericaBonus : Bonus
    {
        public override double Calculate()
        {
            return Contant.BaseSalary * 0.15;
        }
    }

实现产品B

    public class AmericaTax : Tax
    {
        public override double Calculate()
        {
            return Contant.BaseSalary * 0.05 + Contant.BaseSalary * 0.15 * 0.25;
        }
    }

然后是客户端调用代码

   class Program
    {
        static void Main(string[] args)
        {
            //创建抽象工厂模式实例
            AbstractFactory.Server.AbstractFactory factory=AbstractFactory.Server.AbstractFactory.GetInstance();
            var Tax = factory.CreateTax();
            var bonus = factory.CreateBonus();
            double salary = AbstractFactory.Contant.BaseSalary - Tax.Calculate() + bonus.Calculate();
            Console.WriteLine("个人所得奖金为：" + bonus.Calculate());
            Console.WriteLine("个人所得税为："+Tax.Calculate());
            Console.WriteLine("工资为：" + salary);
            Console.ReadLine();
        }
    }

代码下载：Factory.zip