Design Patterns Simplified - Part 3 (Simple Factory)【设计模式简述--第三部分（简单工厂）】

原文链接：http://www.c-sharpcorner.com/UploadFile/19b1bd/design-patterns-simplified-part3-factory/

Design Patterns Simplified - Part 3 (Simple Factory)【设计模式简述--第三部分（简单工厂）】

This article explains why and how to use the Simple Factory Design Pattern in software development.

这篇文章解释了在软件开发中为什么使用，以及怎么使用简单工厂模式。

I am here to continue the discussion of Design Patterns. Today we will explain another creational design pattern called Simple Factory.

我在这继续来讨论设计模式。今天我将会解释另一个创造性的设计模式，也就是简单工厂模式。

In case you have not had a look at our previous articles, go through the following link:

假设你没有看我之前的文章，请先回去看，下面是链接：

• Design Patterns Simplified: Part 1
• Design Patterns Simplified: Part 2 (Singleton)

Before talking about its implementation let's begin with some fundamental questions as in the following.

在讨论如何实现简单工厂模式之前，先看下下面一些基本的问题：

Purpose of the Factory pattern【工厂模式的目的】

I can think of two main objectives of using the Factory pattern. One is to achieve loose coupling between the client and business layer, another is to keep all the code for all the object instantiation logic in one place.

我能想到使用工厂模式的两个主要的目的。一个是在客户端和业务层之间达到松耦合，另外一个是确保所有对象的实例化的逻辑代码都在一个位置。

Purpose of loose coupling【松耦合的目的】

In modern software development where changes in existing systems are frequent and software design is expected to be scalable, not having a loosely-coupled design can create many problems.

在现代软件开发的过程中，需求的变更是很频繁的，所以软件的设计应该是要可扩展性好的，没有一个松耦合的设计，可能会有很多问题。

For example, in an application with a 3-layer architecture, if object creation logic is at the client side, for any new addition of concrete classes, the developer needs to modify not just the business but the client layer as well. Think about the maintainability and added testing effort.

例如，在一个简单三层框架的项目中，如果对象的创建是在客户端，那么任何新添加的具体的实体类，开发者，不仅需要去修改业务层还有客户端层。为了考虑可维护性，还需要添加测试的工作。

How about if the client is only aware of the high-level contracts and not about its concreate implementation?

如果客户端只需要关心和高一层次的关系，而不用关心具体的实现呢？

Yes, you got it right! The client just must pass the type of the object it needs and it will get it using the Factory Pattern.

Enough theory. Now let's talk about implementation.

是的，你是对的！客户端仅仅只需要传递对象需要的类型，剩下的就交给工厂模式去做。理论已经足够了，现在我们来讨论一下，如何实现简单工厂模式吧。

How to use the Simple Factory Pattern【怎么样来使用简单工厂模式】

Let's try to understand using a simple example.

Assume the client wants to know the on-road price of various brands of cars and have an interface as in the following.

我们使用一个简单的例子，来理解简单工厂模式吧。假设客户想要知道路上各种品牌汽车的价格，提供了下面一个这样的接口。

我们创建一个控制台程序，来学习简单工厂模式：

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

namespace ConsoleApplication1
{
   public interface ICar
    {
       /// <summary>
       /// 获取汽车价格
       /// </summary>
       /// <param name="model"></param>
       /// <returns></returns>
       string GetOnRoadPrice(string model);
    }
}

We need to create a Factory class now that will sit between the client and business layers and it will provide the required object to the client based on the car brand passed.

我们现在需要去创建一个工厂类，这个工厂类位于客户端和业务层之间，并基于传递的汽车品牌，提供客户端需要的对象。

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

namespace ConsoleApplication1
{
   public class CarFactory
    {
       /// <summary>
       /// 获取汽车对象
       /// </summary>
       /// <param name="carBrand">汽车品牌</param>
       /// <returns></returns>
       public static ICar GetCar(string carBrand)
       {
           if (carBrand.ToLowerInvariant() == "baoma")
           {
               return new BaoMa();
           }
           else if (carBrand.ToLowerInvariant() == "benchi")
           {
               return new BenChi();
           }
           else if (carBrand.ToLowerInvariant() == "aodi")
           {
               return new AoDi();
           }
           else
           {
               return null;
           }
       }
    }
}

And here goes the concreate business classes.

这里接着创建具体的实体类。

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

namespace ConsoleApplication1
{
    class AoDi:ICar
    {

        public string GetOnRoadPrice(string model)
        {
            if (model.ToLowerInvariant() == "aodi")
            {
                return "300w 人民币";
            }
            else
            {
                return "你输入的汽车品牌找不到，请重新输入！！！";
            }
        }
    }
}

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

namespace ConsoleApplication1
{
    class BaoMa:ICar
    {
        public string GetOnRoadPrice(string model)
        {
            if (model.ToLowerInvariant() == "baoma")
            {
                return "200w 人民币";
            }
            else
            {
                return "你输入的汽车品牌找不到，请重新输入！！！";
            }
        }
    }
}

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

namespace ConsoleApplication1
{
    class BenChi:ICar
    {
      public  string GetOnRoadPrice(string model)
        {
            if (model.ToLowerInvariant() == "glc")
            {
                return "550w 人民币";
            }
            else
            {
                return "你输入的汽车品牌找不到，请重新输入！！！";
            }
        }
    }
}

Now let's see how the client can use the setup we have created so far.

现在，我们看看客户端怎么使用我们目前为止创建的对象。

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            //设置控制台标题栏中显示的标题
            Console.Title = "简单工厂模式Demo学习";
            ICar car = null;
            string model = null;

            //奔驰车测试
           car= CarFactory.GetCar("BenChi");
           model = "glc";
           Console.WriteLine("奔驰系列{0}的汽车，售价为{1}",model,car.GetOnRoadPrice(model));
           Console.ReadKey();
        }
    }
}

And here goes the class diagram.

这是类图：

As you can see in the preceding code, the client is getting the required object by just passing the car brand. And then it calls the GetOnRoadPrice method to get the On-road price by passing model name. So just to summarize, using simple factory, we achieved the following.

上面的代码中你可以看到，客户端获取需要的对象，仅仅通过传递汽车的品牌就可以了。然后传递model name调用GetOnRoadPrice 方法来获取价格。所以总结一下，使用简单工厂模式，我们达到了下面的目的。

• Loose coupling between client and business layers.【客户端和业务层之间的松耦合。】
• Placed object creation logic at common place.【把对象的创建逻辑，放在了一个公共的地方。】
• Abstracted concreate classes (Maruti, Hyundai) from client.【客户端的类抽象化】

I hope you have liked this article. I look forward to your comments/suggestions.

我希望你喜欢这篇文章，期待你的评论和建议。