DesignPattern.Ch8.FactoryMethod.Note

简单工厂vs工厂方法

简单工厂是第二章讲解的内容，它与工厂方法很相似。

简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关类，对客户来说去除了对具体产品的依赖。但是，每次要添加算法，都需要的在客户端怎加一个case分支条件，修改了原有的类，违反了开放-封闭原则。

简单工厂模式复习：

namespace Pattern.FactoryMethod
{
    //首先复习简单工厂
    class OperationFactory
    {
        public static Operation CreateOperation(string type)
        {
            Operation opt = null;
            switch (type)
            {
                case "+": opt = new OperationAdd(); break;
                case "-": opt = new OperationSub(); break;
                case "*": opt = new OperationMul(); break;
                case "/": opt = new OperationDiv(); break;
            }
            return opt;
        }
    }

    abstract class Operation
    {
        public double Left { get; set; }
        public double Right { get; set; }

        public abstract double GetResult();
    }

    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            return Left + Right;
        }
    }
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            return Left - Right;
        }
    }
    class OperationMul : Operation
    {
        public override double GetResult()
        {
            return Left * Right;
        }
    }
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            return Left / Right;
        }
    }
}

namespace Pattern.FactoryMethod
{
    interface IFactory
    {
        Operation CreateOperation();
    }

    class AddFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationAdd();
        }
    }

    class SubFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationSub();
        }
    }

    class MulFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationMul();
        }
    }

    class DivFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationDiv();
        }
    }
}

工厂方法（Factory Method），第一个用于创建对象的接口，让子类决定实例化哪一个工厂类。工厂方法使一个类的实例化延迟到其子类[DP]。

工厂方法只是扩展了变化，并没有违反“开放-封闭原则”。工厂方法把简单工厂的内部逻辑移到了客户端代码中进行，你行增加功能，本来是要修改简单工厂类的，而现在是修改客户端代码。工厂方法是对简单工厂的进一步抽象和推广，工厂模式保持了简单工厂的优点，克服了违反“开放-闭包原则”的缺点，但是由于每增加个产品都要增加一个工厂类，增加了额外的开销。

利用反射可以避免分支判断的问题。

namespace Pattern.FactoryMethod
{
    class LeiFeng
    {
        public void Sweep()
        {
            Console.WriteLine("帮忙扫地。");
        }
        public void Wash()
        {
            Console.WriteLine("洗衣服。");
        }
        public void BuyRice()
        {
            Console.WriteLine("买米。");
        }

    }
    //学雷锋的学生
    class Undergraduate : LeiFeng
    {
    }
    //社区志愿者
    class Volunteer : LeiFeng
    { }
    //雷锋工厂
    interface IFactoryLF
    {
        LeiFeng CreateLeiFeng();
    }

    //学雷锋的大学生工厂
    class UndergraduateFactory : IFactoryLF
    {
        public LeiFeng CreateLeiFeng()
        {
            return new Undergraduate();
        }
    }
    //学雷锋的社区志愿者工厂
    class VolunterFactory:IFactoryLF
    {
        public LeiFeng CreateLeiFeng()
        {
            return new Volunteer();
        }
    }

}

       static void NewbieFactoryMethod()
        {
            IFactoryLF lfFactory = new VolunterFactory();//new UndergraduateFactory();//这里只需要更改创建工厂即可
            LeiFeng lf = lfFactory.CreateLeiFeng();
            lf.BuyRice();
            lf.Wash();
            lf.Sweep();
        }