设计模式：三种工厂模式
Posted renshuozz
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了设计模式：三种工厂模式相关的知识，希望对你有一定的参考价值。
三种工厂模式
简单工厂实现
简单工厂模式（严格来说这不算一种Gof的设计模式，更像是一种编程习惯）属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有相同的父类，应用继承将决定工厂的生产什么产品的决定权直接交到了客户手中，然后客户在输入自己的需求，得到最终的结果。
运用简单工厂模式实现生产pizza的业务场景。
/// <summary>
/// pizza创建工厂
/// </summary>
public class PizzaFactory
public static Pizza CreatePizza(string pizzaType)
switch (pizzaType)
case "Cheese":
return new CheesePizza();
case "ApplePie":
return new ApplePiePizza();
default:
return new SomeOtherPizza();
public abstract class Pizza
public string Name get; set;
public void Prepare()
Console.WriteLine($"Preparing Name");
public void Cut()
Console.WriteLine($"Cutting the Name");
public void Bake()
Console.WriteLine($"Baking the Name");
public void Box()
Console.WriteLine($"Boxing the Name");
public class ApplePiePizza : Pizza
public ApplePiePizza()
Name = "ApplePie";
public class CheesePizza : Pizza
public CheesePizza()
Name = "Cheese";
public class SomeOtherPizza : Pizza
public SomeOtherPizza()
Name = "Other";
//调用
class Program
static void Main(string[] args)
Pizza pizza = PizzaFactory.CreatePizza("cheese");
pizza.Box();
//输出：
//Preparing Cheese
//Cutting the Cheese
//Baking the Cheese
//Boxing the Cheese简单工厂模式实现了生成Pizza类的代码跟客户端代码分离，在工厂类中你可以添加所需的生成Pizza的逻辑代码，但是，简单工厂并不符合“开放-封闭”原则（对扩展开放，对修改关闭），如果要加一种类型VeggiePizza，你就要修改工厂类里面的生成产品的代码，在这里你就要增加Swich-Case。对于这个问题，我们的工厂方法模式就可以解决这个问题。
工厂模式
运用工厂模式实现生产pizza的业务场景。
/// <summary>
/// 工厂接口
/// </summary>
interface IFactory
Pizza CreatePizza();
/// <summary>
/// CheesePizza工厂方法
/// </summary>
public class CheesePizzaFactory : IFactory
public Pizza CreatePizza()
return new CheesePizza();
/// <summary>
/// ApplePiePizza工厂方法
/// </summary>
public class ApplePiePizzaFactory : IFactory
public Pizza CreatePizza()
return new ApplePiePizza();
class Program
static void Main(string[] args)
IFactory factory = new CheesePizzaFactory();
Pizza cheesePizza = factory.CreatePizza();
cheesePizza.Prepare();
cheesePizza.Cut();
cheesePizza.Bake();
cheesePizza.Box();
//输出：
//Preparing Cheese
//Cutting the Cheese
//Baking the Cheese
//Boxing the Cheese
工厂模式中我们通过对应的工厂类来生成对应的Pizza，在这里符合“开闭”原则，无论加多少Pizza类，我们都不用修改原来类中的代码，而是通过增加工厂类来实现。但是这还是有缺点的，如果产品Pizza类过多，我们就要生成很多的工厂类。假如我们要实现的产品接口不止一个，也就是有多个产品接口，不同产品接口有对应的产品族。什么是产品族呢？简单的理解就是，不同类型的Pizza会在不同的地区会有不同的准备方式，以材料（面团Dough,果酱Sauce）的不同而变幻口味等，同地区不同类型的Pizza可以组成一个产品族。对于这种情况我们可以采用抽象工厂模式。
抽象工厂模式
运用工厂模式实现生产pizza的业务场景。
/// <summary>
/// 面团
/// </summary>
public interface Dough
void Dough();
/// <summary>
/// 纽约面团
/// </summary>
public class NYDough : Dough
public void Dough()
Console.WriteLine("NYDough");
/// <summary>
/// 芝加哥面团
/// </summary>
public class ChicagoDough : Dough
public void Dough()
Console.WriteLine("ChicagoDough");
/// <summary>
/// 果酱
/// </summary>
public interface Sauce
void Sauce();
/// <summary>
/// 纽约果酱
/// </summary>
public class NYSauce : Sauce
public void Sauce()
Console.WriteLine("NYSauce");
/// <summary>
/// 芝加哥果酱
/// </summary>
public class ChicagoSauce : Sauce
public void Sauce()
Console.WriteLine("ChicagoSauce");
/// <summary>
/// 建造披萨原料工厂 接口
/// </summary>
public interface IPizzaIngredientFactory
Dough CreateDough();
Sauce CreateSauce();
/// <summary>
/// 纽约披萨工厂
/// </summary>
public class NYPizzaIngredientFactory : IPizzaIngredientFactory
public Dough CreateDough()
return new NYDough();
public Sauce CreateSauce()
return new NYSauce();
/// <summary>
/// 芝加哥披萨工厂
/// </summary>
public class ChicagoPizzaIngredientFactory : IPizzaIngredientFactory
public Dough CreateDough()
return new ChicagoDough();
public Sauce CreateSauce()
return new ChicagoSauce();
public abstract class Pizza
public string Name get; set;
/// <summary>
/// 面团
/// </summary>
public Dough Dough get; set;
/// <summary>
/// 酱汁
/// </summary>
public Sauce Sauce get; set;
public abstract void Prepare();
public void Cut()
Console.WriteLine($"Cutting the Name");
public void Bake()
Console.WriteLine($"Baking the Name");
public void Box()
Console.WriteLine($"Boxing the Name");
public class ApplePiePizza : Pizza
IPizzaIngredientFactory _pizzaIngredientFactory;
public ApplePiePizza(IPizzaIngredientFactory pizzaIngredient)
this._pizzaIngredientFactory = pizzaIngredient;
Name = "ApplePie";
public override void Prepare()
Console.WriteLine($"Preparing Name");
Dough = _pizzaIngredientFactory.CreateDough();
Dough.Dough();
Sauce = _pizzaIngredientFactory.CreateSauce();
Sauce.Sauce();
public class CheesePizza : Pizza
IPizzaIngredientFactory _pizzaIngredientFactory;
public CheesePizza(IPizzaIngredientFactory pizzaIngredient)
this._pizzaIngredientFactory = pizzaIngredient;
Name = "Cheese";
public override void Prepare()
Console.WriteLine($"Preparing Name");
Dough = _pizzaIngredientFactory.CreateDough();
Dough.Dough();
Sauce = _pizzaIngredientFactory.CreateSauce();
Sauce.Sauce();
public class SomeOtherPizza : Pizza
public SomeOtherPizza()
Name = "Other";
public override void Prepare()
throw new NotImplementedException();
// <summary>
/// 工厂接口
/// </summary>
interface IFactory
Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory);
/// <summary>
/// CheesePizza工厂方法
/// </summary>
public class CheesePizzaFactory : IFactory
public Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory)
return new CheesePizza(pizzaIngredientFactory);
/// <summary>
/// ApplePiePizza工厂方法
/// </summary>
public class ApplePiePizzaFactory : IFactory
public Pizza CreatePizza(IPizzaIngredientFactory pizzaIngredientFactory)
return new ApplePiePizza(pizzaIngredientFactory);
//调用
class Program
static void Main(string[] args)
IPizzaIngredientFactory pizzaIngredientFactory = new NYPizzaIngredientFactory();
IFactory factory = new CheesePizzaFactory();
Pizza cheesePizza = factory.CreatePizza(pizzaIngredientFactory);
cheesePizza.Prepare();
cheesePizza.Cut();
cheesePizza.Bake();
cheesePizza.Box();
//输出：
//Preparing Cheese
//NYDough
//NYSauce
//Cutting the Cheese
//Baking the Cheese
//Boxing the Cheese
总结
简单工厂优点
- 实现了对象创建和使用的分离，调用者可以免除直接创建产品对象的职责，而仅仅"消费"产品。
调用者无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的的参数即可。
简单工厂缺点
- 工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受影响。
系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能会造成工厂逻辑过于复杂，不利于系统的扩展和维护。
工厂优点
- 工厂方法用于创建客户所需要的产品，还向客户隐藏了哪种具体产品类将被实例化这一细节。因此，用户只需要关心所需产品对应的工厂，无须关心创建细节。
在系统中加入新产品时，无需修改抽象工厂和抽象产品提供的接口，也无须修改客户端，还无须修改其他的具体工厂和具体产品，而只要加入一个具体工厂和具体产品就可以了。因此，系统的可扩展性得到了保证，符合开闭原则。
工厂缺点
- 在添加新产品时，需要编写新的具体产品类，还要提供与之对应的具体工厂类，系统中类的个数将成对增加，一定程度上增加了系统的复杂度。
由于考虑到系统的可扩展性，需要引入抽象层，且在实现时可能需要用到反射等技术，增加了系统的实现难度。
抽象工厂优点
- 隔离了具体类的生成，使得客户并不需要知道什么被创建。因为这种隔离，因此更换一个具体工厂就变得相对容易。
- 当一个产品族中的多个对象被设计称一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
增加新的产品族很方便，无需修改已有系统，符合开闭原则。
抽象工厂缺点
增加新的产品等级结构因为需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这必然会带来较大的不便，在这个角度，它违背了开闭（对扩展开放，对修改封闭）原则。
以上是关于设计模式：三种工厂模式的主要内容，如果未能解决你的问题，请参考以下文章