抽象工厂模式（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();

        }
    }
}

运行截图：

最后是直观的关系图：

转载于:https://www.cnblogs.com/NewWork/archive/2013/06/10/3260560.html