设计模式笔记：简单工厂模式（Simple Factory）

1. 简单工厂模式简介

1.1 定义

　　简单工厂模式：定义一个Factory类，可以根据参数的不同返回不同类的实例，被创建的实例通常有共同的父类。

　　简单工厂模式：只需要一个Factory类。

　　简单工厂模式：又称为静态工厂模式（Static Factory Pattern），Factory类为静态类或包含静态方法。

　　简单工厂模式：不属于23种GOF设计模式。

　　简单工厂模式：实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类实例。

1.2 使用频率

　　 中

2. 简单工厂模式结构

2.1 结构图

2.2 参与者

　　简单工厂模式参与者：

　　◊ Product：抽象产品类，将具体产品类公共的代码进行抽象和提取后封装在一个抽象产品类中。

　　◊ ConcreteProduct：具体产品类，将需要创建的各种不同产品对象的相关代码封装到具体产品类中。

　　◊ Factory：工厂类，提供一个工厂类用于创建各种产品，在工厂类中提供一个创建产品的工厂方法，该方法可以根据所传入参数的不同创建不同的具体产品对象。

　　◊ Client：客户端类，只需调用工厂类的工厂方法并传入相应的参数即可得到一个产品对象。

3. 简单工厂模式结构实现

3.1 Product类抽象实现

　　Product.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Structural
{
    public abstract class Product
    {
    }
}

　　ConcreteProduct.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Structural
{
    public class ConcreteProduct : Product
    {
    }
}

　　Factory.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Structural
{
    public class Factory
    {
        /// <summary>
        /// 静态方法创建Product实例
        /// </summary>
        public static Product CreateProduct()
        {
            return new ConcreteProduct();
        }
    }
}

　　Program.cs

using System;
using System.Collections.Generic;
using System.Text;

using DesignPatterns.SimpleFactoryPattern.Structural;

namespace DesignPatterns.SimpleFactoryPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            Product product = Factory.CreateProduct();
            Console.WriteLine("Created {0}", product.GetType().Name);
        }
    }
}

　　运行结果：

Created ConcreteProduct
请按任意键继续. . .

3.2 Product接口类实现

　　IProduct.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.StructuralInterfaceImplementation
{
    public interface IProduct
    {
        void Display();
    }
}

　　Product.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.StructuralInterfaceImplementation
{
    public class Product : IProduct
    {
        public void Display()
        {
            Console.WriteLine("DesignPatterns.SimpleFactoryPattern.Structural.Product");
        }
    }
}

　　Factory.cs

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

using System.Reflection;

namespace DesignPatterns.SimpleFactoryPattern.StructuralInterfaceImplementation
{
    public class Factory
    {
        /// <summary>
        /// Factory返回IProduct的静态方法
        /// </summary>
        /// <returns></returns>
        public static IProduct Create()
        {
            // 使用new直接创建接口的具体类
            //return new DesignPatterns.SimpleFactoryPattern.StructuralInterfaceImplementation.Product();

            // 通过映射创建接口的具体类
            return (IProduct)Assembly.Load("DesignPatterns.SimpleFactoryPattern").CreateInstance("DesignPatterns.SimpleFactoryPattern.StructuralInterfaceImplementation.Product");
        }
    }
}

　　Program.cs

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

using DesignPatterns.SimpleFactoryPattern.StructuralInterfaceImplementation;

namespace DesignPatterns.SimpleFactoryPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            IProduct product = Factory.Create();
            product.Display();
        }
    }
}

4. 简单工厂模式实践应用

4.1 实践应用——运算操作

　　Operation.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    /// <summary>
    /// 运算类
    /// </summary>
    public abstract class Operation
    {
        public double NumberA { get; set; }
        public double NumberB { get; set; }

        public virtual double GetResult()
        {
            const double result = ;
            return result;
        }
    }
}

　　Plus.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    /// <summary>
    /// 加法运算
    /// </summary>
    public class Plus : Operation
    {
        public override double GetResult()
        {
            return NumberA + NumberB;
        }
    }
}

　　Minus.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    /// <summary>
    /// 减法运算
    /// </summary>
    public class Minus : Operation
    {
        public override double GetResult()
        {
            return NumberA - NumberB;
        }
    }
}

　　Multiply.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    public class Multiply : Operation
    {
        public override double GetResult()
        {
            return NumberA * NumberB;
        }
    }
}

　　Divide.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    public class Divide :Operation
    {
        public override double GetResult()
        {
            return NumberA / NumberB;
        }
    }
}

　　OperationFactory.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    public class OperationFactory
    {
        public static Operation CreateOperate(string operate)
        {
            Operation operation = null;

            switch (operate)
            {
                case "+":
                    operation = new Plus();
                    break;
                case "-":
                    operation = new Minus();
                    break;
                case "*":
                    operation = new Multiply();
                    break;
                case "/":
                    operation = new Divide();
                    break;
            }

            return operation;
        }
    }
}

　　Program.cs

using System;
using System.Collections.Generic;
using System.Text;

using DesignPatterns.SimpleFactoryPattern.Practical;

namespace DesignPatterns.SimpleFactoryPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            Operation operateion = OperationFactory.CreateOperate("+");
            operateion.NumberA = ;
            operateion.NumberB = ;

            Console.WriteLine(operateion.GetResult());
        }
    }
}

4.2 实践应用——银行支付接口

　　IPayment.cs

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

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    public interface IPayment
    {
        bool Payfor(decimal money);
    }
}

　　ABCPayment.cs

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

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    public class ABCPayment : IPayment
    {
        public bool Payfor(decimal money)
        {
            // 调用中国农业银行支付接口进行支付
            return true;
        }
    }
}

　　ICBCPayment.cs

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

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
    public class ICBCPayment : IPayment
    {
        public bool Payfor(decimal money)
        {
            // 调用中国工商银行支付接口进行支付
            return true;
        }
    }
}

　　PaymentFactory.cs

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

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
   public class PaymentFactory
    {
       public static IPayment CreatePayment(string bank)
       {
           IPayment payment = null;
           switch (bank)
           {
               case "ABC":
                   payment = new ABCPayment();
                   break;
               case "ICBC":
                   payment = new ICBCPayment();
                   break;
           }

           return payment;
       }
    }
}

　　OrderService.cs

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

namespace DesignPatterns.SimpleFactoryPattern.Practical
{
   public class OrderService
    {
       public bool CreateOrder(string bank)
       {
           decimal money=100m;
           var payment = PaymentFactory.CreatePayment(bank);

           return payment.Payfor(money);
       }
    }
}

　　在OrderService类中，不依赖具体的支付类，只通过PaymentFactory来获取真正的支付类。

5. 简单工厂模式应用分析

5.1 简单工厂模式优点

　　◊ 实现创建和使用分离；

　　◊ Client无需知道所创建的ConcreteProduct类名，只需要知道ConcreteProduct所对应的参数。

5.2 简单工厂模式缺点

　　◊ Factory类集中所有ConcreteProduct的创建逻辑，职责过重。一旦需要添加新的ConcreteProduct，则需要修改Factory逻辑。这样违背了OCP（开放-关闭原则）。

　　◊ 由于使用了static方法，造成Factory无法形成基于继承的结构。