本文的概念性内容来自深入浅出设计模式一书.

上一篇文章讲了简单工厂和工厂方法设计模式 http://www.cnblogs.com/cgzl/p/8760250.html, 使用的是披萨店的例子.

文将继续使用这个例子, 这里要用到抽象工厂.

披萨店的需求变更

现在披萨店在各地授权了很多连锁分店, 但是有的分店偷工减料, 使用劣质原料代替标准原料.

披萨店老板现在就是想解决这个问题.

原料的一致性问题

首先如何保证原料的质量问题? 可以建立一个工厂生产原料, 然后把原料分发到各地的授权店.

然后还有一个原料的一致性问题, 例如纽约的番茄酱和芝加哥的番茄酱可能有点不同, 所以它们各自需要一套原料.

也就是说各地的披萨是使用相同的原料, 但是每种原料在各地可能会存在差异(不同的实现).

这就是纽约, 芝加哥和加州各自的原料家族.

建立原料工厂

接下来就是建立原料工厂, 这些工厂将负责为各自的家族(地点)创建原料.

首先是工厂的接口:

然后我们要做下面这些内容:

  • 为每个地区创建一个工厂 (实现PizzaIngredientFactory接口及其方法)
  • 实现一些原料的类, 它们可以呗工厂使用, 其中某些原料可以跨地区共享
  • 最后我们把上面这些整合到PizzaStore里面.

纽约的原料工厂:

就是实现接口, 返回本地需要的原料而已.

修改Pizza抽象类:

这里我们把Prepare()方法(准备原料)改成抽象的了, 其它的保持不变.

接下来需要为各地创建不同风格的披萨了. 现在各地披萨店的原料都是从工厂送来的, 就不能使用劣质原料代替了.

之前使用工厂方法模式时, 我们为每个地点创建了不同风格的披萨, 例如 NYCheesePizza, ChicagoCheesePizza. 你可以看一下这两个类, 它们里面只有原料部分(都是同样的原料, 但是各地风格不同)是不同的.

所以实际上, 我们不需要为每个地点创建不同风格的披萨, 原料工厂将会替我们处理各地风格披萨原料不同这种情况.

例如奶酪披萨只需要一个类就可以:

为了创建奶酪披萨, 在其构造函数里面传入原料工厂为它提供原料即可.

在prepare()方法里面准备的原料都是工厂来提供的.

使用哪些地区/风格的原料由工厂决定, 披萨类本身并不关心, 它只需知道怎么制作披萨就行.

这样披萨类和各地区的原材料就解耦了.

综上, 就是一句话:

原料由工厂提供.

可以再看看另外一个披萨的例子:

修改各地的披萨店

纽约的披萨店现在和纽约的原料工厂组合在一起, 这样它就可以产出纽约风格的披萨了.

在创建披萨的时候把原料工厂传进去为披萨提供原料.

到目前位置, 我们做了什么?

我们提供了一种可以为披萨提供一族原料的工厂, 这个工厂就叫做抽象工厂.

抽象工厂为创建某一家族的产品提供接口(interface), 针对这个接口编程, 就可以实现从具体生产产品的工厂解耦.

这样做就允许我们为不同的上下文使用不同实现的工厂了.

因为我们的代码是从实际产品解耦的, 我们就可以通过替换工厂来取得不同风格的产品了.

梳理一下整个流程

1. 创建纽约的披萨店:

2. 下订单买披萨

3. orderPizza方法调用创建披萨的方法:

到这, 代码都没有变化.

4.创建披萨的时候, 使用原料工厂:

5. 披萨的准备工序里是由工厂来提供原料:

6. 按照其他工序加工并返回披萨.

抽象工厂定义

抽象工厂设计模式提供了一个接口, 这个接口可以创建一族相关或依赖的对象而无需指明它们具体的类.

下面是类图:

对应披萨店的图:

工厂方法和抽象工厂的比较

工厂方法是通过继承来实现创建对象工作的. 而抽象工厂则是通过组合的方法.

工厂方法是让子类来创建对象, 客户只需要知道抽象类, 子类做具体的实现, 解耦.

抽象工厂提供了一个可以创建一族产品的抽象类, 这个类的实现类/子类决定产品是如何产出的, 也是解耦.

抽象工厂的优点是: 可以创建一族相关的产品. 缺点是它的接口比较大, 如果添加产品了需要改接口.

而工厂方法只负责生产一个产品.

抽象工厂也经常使用工厂方法来实现具体的工厂.

而工厂方法也经常使用抽象的创造者, 它来使用子类创造出的具体产品.

工厂方法:

抽象工厂:

总结

C#/.NET Core代码实现

原料接口:

namespace AbstractFactoryPattern.Abstractions
{
public interface IGredient
{
string Name { get; }
}
} namespace AbstractFactoryPattern.Abstractions
{
public interface ICheese: IGredient
{
}
} namespace AbstractFactoryPattern.Abstractions
{
public interface IClams: IGredient
{
}
} namespace AbstractFactoryPattern.Abstractions
{
public interface IDough: IGredient
{
}
} namespace AbstractFactoryPattern.Abstractions
{
public interface ISauce: IGredient
{
}
}

原料工厂接口:

namespace AbstractFactoryPattern.Abstractions
{
public interface IPizzaIngredientFactory
{
IDough CreateDough();
ICheese CreateCheese();
IClams CreateClams();
ISauce CreateSauce();
}
}

披萨店抽象类:

namespace AbstractFactoryPattern.Abstractions
{
public abstract class PizzaStore
{
public Pizza OrderPizza(string type)
{
var pizza = CreatePizza(type);
pizza.Prepare();
pizza.Bake();
pizza.Cut();
pizza.Box();
return pizza;
} protected abstract Pizza CreatePizza(string type);
}
}

披萨抽象类:

using System;

namespace AbstractFactoryPattern.Abstractions
{
public abstract class Pizza
{
public string Name { get; set; }
public IDough Dough { get; protected set; }
public ISauce Sauce { get; protected set; }
public ICheese Cheese { get; protected set; }
public IClams Clams { get; protected set; } public abstract void Prepare(); public void Bake()
{
Console.WriteLine("Bake for 25 minutes");
} public void Cut()
{
Console.WriteLine("Cutting the pizza into diagnol slices");
} public void Box()
{
Console.WriteLine("Placing pizza in official PizzaStore box......");
}
}
}

具体原料:

using AbstractFactoryPattern.Abstractions;

namespace AbstractFactoryPattern.Ingredients
{
public class FreshClams : IClams
{
public string Name { get; } = "Fresh Clams";
}
} using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.Ingredients
{
public class FrozenClams: IClams
{
public string Name { get; } = "Frozen Clams";
}
} using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.Ingredients
{
public class MarinaraSauce: ISauce
{
public string Name { get; } = "Marinara Sauce";
}
} using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.Ingredients
{
public class MozzarellaCheese: ICheese
{
public string Name { get; } = "Mozzarella Cheese";
}
} using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.Ingredients
{
public class PlumTomatoSauce : ISauce
{
public string Name { get; } = "Plum Tomato Sauce";
}
} using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.Ingredients
{
public class ReggianoCheese : ICheese
{
public string Name { get; } = "Reggiano Cheese";
}
} using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.Ingredients
{
public class ThickCrustDough: IDough
{
public string Name { get; } = "Thick Crust Dough";
}
} using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.Ingredients
{
public class ThinCrustDough: IDough
{
public string Name { get; } = "Thin Crust Dough";
}
}

具体披萨:

using System;
using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.ConcreteProducts
{
public class CheesePizza: Pizza
{
private readonly IPizzaIngredientFactory _pizzaIngredientFactory; public CheesePizza(IPizzaIngredientFactory pizzaIngredientFactory)
{
_pizzaIngredientFactory = pizzaIngredientFactory;
} public override void Prepare()
{
Console.WriteLine($"Preparing: {Name}");
Dough = _pizzaIngredientFactory.CreateDough();
Sauce = _pizzaIngredientFactory.CreateSauce();
Clams = _pizzaIngredientFactory.CreateClams();
Cheese = _pizzaIngredientFactory.CreateCheese();
Console.WriteLine($" {Dough.Name}");
Console.WriteLine($" {Sauce.Name}");
Console.WriteLine($" {Clams.Name}");
Console.WriteLine($" {Cheese.Name}");
}
}
} using System;
using AbstractFactoryPattern.Abstractions; namespace AbstractFactoryPattern.ConcreteProducts
{
public class ClamsPizza : Pizza
{
private readonly IPizzaIngredientFactory _pizzaIngredientFactory; public ClamsPizza(IPizzaIngredientFactory pizzaIngredientFactory)
{
_pizzaIngredientFactory = pizzaIngredientFactory;
} public override void Prepare()
{
Console.WriteLine($"Preparing: {Name}");
Dough = _pizzaIngredientFactory.CreateDough();
Sauce = _pizzaIngredientFactory.CreateSauce();
Clams = _pizzaIngredientFactory.CreateClams();
Console.WriteLine($" {Dough.Name}");
Console.WriteLine($" {Sauce.Name}");
Console.WriteLine($" {Clams.Name}");
}
}
}

各地原料工厂:

using AbstractFactoryPattern.Abstractions;
using AbstractFactoryPattern.Ingredients; namespace AbstractFactoryPattern.ConcreteFactories
{
public class ChicagoPizzaIngredientFactory: IPizzaIngredientFactory
{
public IDough CreateDough()
{
return new ThinCrustDough();
} public ICheese CreateCheese()
{
return new ReggianoCheese();
} public IClams CreateClams()
{
return new FrozenClams();
} public ISauce CreateSauce()
{
return new PlumTomatoSauce();
}
}
} using AbstractFactoryPattern.Abstractions;
using AbstractFactoryPattern.Ingredients; namespace AbstractFactoryPattern.ConcreteFactories
{
public class NewYorkPizzaIngredientFactory: IPizzaIngredientFactory
{
public IDough CreateDough()
{
return new ThickCrustDough();
} public ICheese CreateCheese()
{
return new MozzarellaCheese();
} public IClams CreateClams()
{
return new FreshClams();
} public ISauce CreateSauce()
{
return new MarinaraSauce();
}
}
}

各地披萨店:

using AbstractFactoryPattern.Abstractions;
using AbstractFactoryPattern.ConcreteFactories;
using AbstractFactoryPattern.ConcreteProducts; namespace AbstractFactoryPattern.Clients
{
public class ChicagoPizzaStore : PizzaStore
{
protected override Pizza CreatePizza(string type)
{
var factory = new ChicagoPizzaIngredientFactory();
Pizza pizza = null;
switch (type)
{
case "cheese":
pizza = new CheesePizza(factory);
pizza.Name = "Chicago Cheese Pizza";
break;
case "clams":
pizza = new ClamsPizza(factory);
pizza.Name = "Chicago Clams Pizza";
break;
}
return pizza;
}
}
} using AbstractFactoryPattern.Abstractions;
using AbstractFactoryPattern.ConcreteFactories;
using AbstractFactoryPattern.ConcreteProducts; namespace AbstractFactoryPattern.Clients
{
public class NewYorkPizzaStore : PizzaStore
{
protected override Pizza CreatePizza(string type)
{
var factory = new NewYorkPizzaIngredientFactory();
Pizza pizza = null;
switch (type)
{
case "cheese":
pizza = new CheesePizza(factory);
pizza.Name = "New York Cheese Pizza";
break;
case "clams":
pizza = new ClamsPizza(factory);
pizza.Name = "New York Clams Pizza";
break;
}
return pizza;
}
}
}

测试运行:

using System;
using AbstractFactoryPattern.Clients; namespace AbstractFactoryPattern
{
class Program
{
static void Main(string[] args)
{
var newYorkPizzaStore = new NewYorkPizzaStore();
newYorkPizzaStore.OrderPizza("cheese"); Console.WriteLine("-----------------------------------------------------------"); var chicagoYorkPizzaStore = new ChicagoPizzaStore();
chicagoYorkPizzaStore.OrderPizza("cheese"); Console.ReadKey();
}
}
}

Ok.

使用C# (.NET Core) 实现抽象工厂设计模式 (Abstract Pattern)的更多相关文章

  1. 用C# (.NET Core) 实现抽象工厂设计模式

    用C# (.NET Core) 实现抽象工厂设计模式   本文的概念性内容来自深入浅出设计模式一书. 上一篇文章讲了简单工厂和工厂方法设计模式 http://www.cnblogs.com/cgzl/ ...

  2. 乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)

    原文:乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern) [索引页][源码下载] 乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factor ...

  3. 【设计模式】抽象工厂模式 Abstract Factory Pattern

    简单工厂模式是一个工厂类根据工厂方法的参数创建不出不同的产品, 工厂方法模式是每一个产品都有一个一一对应的工厂负责创建该产品.那么今天要讲的抽象工厂模式是一个工厂能够产生关联的一系列产品.抽象工厂模式 ...

  4. C#--抽象工厂设计模式原理

    C#--抽象工厂设计模式原理 C#--抽象工厂设计模式--三层框架 C#--使用反射改进简单工厂

  5. .NET设计模式(2):1.2 抽象工厂模式(Abstract Factory)

    概述 抽象工厂模式(Abstract Factory)是所有形态的工厂模式中最为抽象和最具一般性的一种形态.抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式.抽象工厂模式可以向客户端提供一个接口 ...

  6. 浅谈C++设计模式之抽象工厂(Abstract Factory)

    抽象工厂(Abstract Factory)模式是为了提供一系列相关或相互依赖对象的接口.对象创建型模式的一种. 客户Client 抽象工厂接口AbstractFactory 抽象工厂的实现类Conc ...

  7. 设计模式 - 抽象工厂模式(abstract factory pattern) 具体解释

    抽象工厂模式(abstract factory pattern) 详细解释 本文地址: http://blog.csdn.net/caroline_wendy/article/details/2709 ...

  8. 二十四种设计模式:抽象工厂模式(Abstract Factory Pattern)

    抽象工厂模式(Abstract Factory Pattern) 介绍提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 示例有Message和MessageModel,Messag ...

  9. 【UE4 设计模式】抽象工厂模式 Abstract Factory Pattern

    概述 描述 提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类:具体的工厂负责实现具体的产品实例 抽象工厂中每个工厂可以创建多种产品(如苹果公司生产iPhone.iPad): 工厂方法 ...

随机推荐

  1. IntelliJ IDEA添加JUnit单元测试

    使用idea IDE 进行单元测试,首先需要安装JUnit 插件. 1.安装JUnit插件步骤 File-->settings-->Plguins-->Browse reposito ...

  2. Codeforces 1144F Graph Without Long Directed Paths (DFS染色+构造)

    <题目链接> 题目大意:给定一个无向图,该无向图不含自环,且无重边.现在要你将这个无向图定向,使得不存在任何一条路径长度大于等于2.然后根输入边的顺序,输出构造的有向图.如果构造的边与输入 ...

  3. 微信小程序 + nodeJs(loopback) 实现支付

    实现小程序的支付,首先需要去微信官网先了解一下微信小程序支付相关接口文档:https://pay.weixin.qq.com/wiki/doc/api/wxa/wxa_api.php?chapter= ...

  4. 我对PMO的理解(持续更新)

    PMO的价值 为项目管理提供方法上的指导,对项目的实施过程提供监督.评价. PMO应该从哪方面着手建立管理体系 如何量化工作 如何考评工作 如何激励员工 如何进行人工.成本核算 如何进行进度跟踪与控制 ...

  5. 使用SQL-Front启动MySQL8.0报错

    这学期学习数据库,电脑上分别装有phpStudy(自带的MySQL版本为5.5)和MySQL8.0.11,于是想用phpStudy中的SQL Front连接到8.0的数据库.手动开启8.0的MySQL ...

  6. tensorflow 使用 4 非线性回归

    # 输入一个 x 会计算出 y 值 y 是预测值,如果与 真的 y 值(y_data)接近就成功了 import tensorflow as tf import numpy as np # py 的画 ...

  7. 在dcef3当中执行js代码并获得返回值

    1.如何在dcef3当中执行js代码 procedure TForm1.btnWriteZMClick(Sender: TObject);var  js: string;begin  js := 'd ...

  8. 资源验证(Modified)

    Last-Modified : 上次修改时间 配合 If-Modified-Since 或者 If-Unmodified-Since  (请求头携带) 对比上次修改时间对资源进行验证 Etag验证 数 ...

  9. 如何使用$.each()与$().each()以及他们的区别

    1.首先,说下$.each(Arry/Object,function(index,val){ //index表示下标,val表示下标对应的值 }) 下面是使用$.each()的几种类型,其中arr2与 ...

  10. leetcode-求众数

    题目:求众数 给定一个大小为 n 的数组,找到其中的众数.众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素. 你可以假设数组是非空的,并且给定的数组总是存在众数. 示例 1: 输入: [3,2,3 ...