抽象工厂模式(C#)
1. 适用性
在以下情况可以使用AbstractFactory模式
• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品类库,而只想显示它们的接口而不是实现时。
2. 参与者
• A b s t r a c t Fa c t o r y
— 声明一个创建抽象产品对象的操作接口。
• C o n c r e t e Fa c t o r y
— 实现创建具体产品对象的操作。
• A b s t r a c t Pr o d u c t
— 为一类产品对象声明一个接口。
• C o n c r e t e Pr o d u c t
— 定义一个将被相应的具体工厂创建的产品对象。
— 实现A b s t r a c t P r o d u c t接口。
• C l i e n t
— 仅使用由A b s t r a c t F a c t o r y和A b s t r a c t P r o d u c t类声明的接口。
3. 协作
• 通常在运行时刻创建一个C o n c r e t e F a c t r o y类的实例。这一具体的工厂创建具有特定实现
的产品对象。为创建不同的产品对象,客户应使用不同的具体工厂。
• AbstractFactory将产品对象的创建延迟到它的C o n c r e t e F a c t o r y子类。
8. 效果
A b st r a c t F a c t o r y模式有下面的一些优点和缺点:
1) 它分离了具体的类 Abstract Factory模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程,它将客户与类的实现分离。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离;它们不出现在客户代码中。
2) 它使得易于交换产品系列 一个具体工厂类在一个应用中仅出现一次—即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置,这是因为一个抽象工厂创建了一个完整的产品系列,所以整个产品系列会立刻改变
3) 它有利于产品的一致性 当一个系列中的产品对象被设计成一起工作时,一个应用一次只能使用同一个系列中的对象,这一点很重要。而A b s t r a c t F a c t o r y很容易实现这一点。
4) 难以支持新种类的产品 难以扩展抽象工厂以生产新种类的产品。这是因为A b s t r a c t F a c t o r y接口确定了可以被创建的产品集合。支持新种类的产品就需要扩展该工厂接口,这将涉及A b s t r a c t F a c t o r y类及其所有子类的改变。我们会在实现一节讨论这个问题的一个解决
办法。
下面是用C#语言简单的实现:
类图:
AbstractFactory等类的源码:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AbstractFactory { //申明抽象的产品类A abstract class AbstractProductA { abstract public void RightProduct(); } //AbstractProductA 的具体的子类 class ProductA1 : AbstractProductA { public override void RightProduct() { Console.WriteLine("This is the real Product ProductA One! "+this.GetType().ToString()); } } class ProductA2 : AbstractProductA { public override void RightProduct() { Console.WriteLine("This is the real Product ProductA Two! "+this.GetType().ToString()); } } //申明抽象的产品类B abstract class AbstractProductB { abstract public void RightProduct(); } //AbstractProductB 的具体的子类 class ProductB1 : AbstractProductB { public override void RightProduct() { Console.WriteLine("This is the real Product ProductB One! " + this.GetType().ToString()); } } class ProductB2 : AbstractProductB { public override void RightProduct() { Console.WriteLine("This is the real Product ProductB Two! " + this.GetType().ToString()); } } //抽象工厂 abstract class MyAbstractFactory { abstract public AbstractProductA CreatProductA(); abstract public AbstractProductB CreatProductB(); } //抽象工厂的子类,主要是某类产品的工厂 class ConcreteFactory1 : MyAbstractFactory { public override AbstractProductA CreatProductA() { return new ProductA1(); } public override AbstractProductB CreatProductB() { return new ProductB1(); } } class ConcreteFactory2 : MyAbstractFactory { public override AbstractProductA CreatProductA() { return new ProductA2(); } public override AbstractProductB CreatProductB() { return new ProductB2(); } } }主程序源码:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AbstractFactory { class Program { static void Main(string[] args) { MyAbstractFactory Factory1 = new ConcreteFactory1(); MyAbstractFactory Factory2 = new ConcreteFactory2(); AbstractProductA AProductA1 = Factory1.CreatProductA(); AbstractProductA AProductA2 = Factory2.CreatProductA(); AbstractProductB AProductB1 = Factory1.CreatProductB(); AbstractProductB AProductB2 = Factory2.CreatProductB(); AProductA1.RightProduct(); AProductA2.RightProduct(); AProductB1.RightProduct(); AProductB2.RightProduct(); Console.ReadKey(); } } }
运行截图:
最后是直观的关系图: