.Net 抽象工厂(Abstract Factory)

目录

1. 定义
2. UML
3. 参与者(角色)
4. 示例(分析)

定义：

抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式针对的是多个产品等级结构。

UML:

参与者：

抽象工厂（Abstract Factory）角色：声明一个抽象方法用于创建抽象产品业务。

具体工厂（Concrete Factory）角色：实现这个抽象工厂的具体对象。

抽象产品（Abstract Product）角色：声明一个抽象的产品对象

具体产品（Concrete Product）角色：实现抽象产品对象。

客户 (Client) 角色：调用抽象工厂来实现某个具体的产品。

 

示例分析：

从上面的UML来看，ProductA继承了AbstractProductA这个抽象类，这个抽象类中放了一些抽象方法，这些方法必须有子类来实现它。

由于产品的多样化，必然会实例化多个产品，于是我们引入了抽象工厂（AbstractFactory）。抽象工厂里面放了创建某个产品的抽象方法。有了这个抽象工厂，我们必须要实现这个抽象工厂吧，于是有了具体工厂（ConcreteFactory）。那么我们调用方（Client）只要调用抽象工厂来调用该工厂相应的方法就可以了。

using System;

namespace Abstract_Factory
{
    public class ProductA : AbstractProductA
    {
        public override void Run()
        {
            Console.WriteLine("run productA");
        }
    }

    public class ProductB : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + "  和 " + a.GetType().Name);
        }
    }
}

namespace Abstract_Factory
{
    public abstract class AbstractProductA
    {
        public abstract void Run();
    }

    public abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }
}

namespace Abstract_Factory
{
    public abstract class AbstarctFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }
}

namespace Abstract_Factory
{
    public class ConcreteFactory1 : AbstarctFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA();
        }

        public override AbstractProductB CreateProductB()
        {
            return new ProductB();
        }
    }
}

namespace Abstract_Factory
{
    public class Client
    {
        private AbstractProductA _abstractProductA;
        private AbstractProductB _abstractProductB;

        public Client(AbstarctFactory abstarctFactory)
        {
            _abstractProductA = abstarctFactory.CreateProductA();
            _abstractProductB = abstarctFactory.CreateProductB();
        }

        public void RunClient()
        {
            _abstractProductA.Run();
        }

        public void GetMessage()
        {
            _abstractProductB.Interact(_abstractProductA);
        }
    }
}

 

namespace Abstract_Factory
{
    class Program
    {
        static void Main(string[] args)
        {
            AbstarctFactory abstarctFactory = new ConcreteFactory1();
            Client client = new Client(abstarctFactory);
            client.RunClient();
            client.GetMessage();
            Console.Read();

        }
    }
}