抽象工厂

接上一篇的工厂方法继续工厂模式的练习。

先看一下抽象工厂的结构图

产品族：

在上面的产品列表中呢，有两个产品族，一个是“具体产品A--1”和”具体产品B--1“组成的一个族，

还有一个是“具体产品A--2”和“具体产品B--2”组成的一个族。

产品族就是在不同产品等级结构中，功能相关联的产品组成的家族。

抽象工厂的定义：

提供一个创建一系列相关或者是相互依赖对象的接口，而无需指定它们具体的类

这副类图中可以看出，每一个具体的工厂，它都只负责创建一个产品族中的产品的实例，

从抽象工厂中派生出的具体工厂，这些具体工厂产生相同的产品（这些产品都继承自同一父类），

比如，ConcreteFactory1 和 ConcreteFactory2 中的 CreateProductA 这个方法都是产生 AbstractProductA 这种类型的产品，

但是产品的实现却是不同的，比如 ConcreteFactory1 中的 CreateProductA 实现的是产生一个 ConcreteProductA—1 产品，

而 ConcreteFactory2 中的 CreateProductA 实现的是产生一个 ConcreteProductA—2 产品，

总的来说就是不同的具体工厂产生不同的产品族，

而抽象工厂则是定义一个负责创建一组产品（也就是一个产品族）的接口，

比如上面的类图中只存在两个产品族，所以在抽象工厂中便只需要定义两个接口就可以了。

实现思路：

这里我们以支付宝和微信举例：

支付宝和微信属于两个产品，这两个产品有两个共有的功能是：聊天和支付。

但两个产品的这两个功能实现机制不同，所以这里用抽象工厂模式实现这个场景。

工厂：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractFactory
{
    /// <summary>
    /// 支付；支付产品族
    /// </summary>
    public abstract class Pay
    {
        public abstract void PayWay();
    }

    /// <summary>
    /// 聊天；聊天产品族
    /// </summary>
    public abstract class Talk
    {
        public abstract void TalkWay();
    }

    /// <summary>
    /// 抽象工厂，应该包含所有共有方法，提供被其他子工厂继承
    /// </summary>
    public abstract class AbstractFactory
    {
        public abstract Pay CreatePay();
        public abstract Talk CreakTalk();
    }

    /// <summary>
    /// 阿里支付实现
    /// </summary>
    public class AliPay : Pay
    {
        public override void PayWay()
        {
            Console.WriteLine("我使用的支付产品是支付宝：{0}",this.GetType()); 
        }
    }

    /// <summary>
    /// 微信支付实现
    /// </summary>
    public class WeChatPay : Pay
    {
        public override void PayWay()
        {
            Console.WriteLine("我使用的支付产品是微信：{0}",this.GetType()); 
        }
    }

    /// <summary>
    /// 阿里聊天实现
    /// </summary>
    public class AliTalk : Talk
    {
        public override void TalkWay()
        {
            Console.WriteLine("我使用的聊天产品是支付宝：{0}", this.GetType()); 
        }
    }

    /// <summary>
    /// 微信聊天实现
    /// </summary>
    public class WeChatTalk : Talk
    {
        public override void TalkWay()
        {
            Console.WriteLine("我使用的聊天产品是微信：{0}", this.GetType()); 
        }
    }

    /// <summary>
    /// 支付宝工厂实现
    /// </summary>
    public class AliFactory : AbstractFactory
    {
        public override Pay CreatePay()
        {
            return new AliPay();
        }

        public override Talk CreakTalk()
        {
            return new AliTalk();
        }
    }

    /// <summary>
    /// 微信工厂实现
    /// </summary>
    public class WeChatFactory : AbstractFactory
    {
        public override Pay CreatePay()
        {
            return new WeChatPay();
        }

        public override Talk CreakTalk()
        {
            return new WeChatTalk();
        }
    }
}

 客户端：

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)
        {
            AbstractFactory abstractFactory;
            Pay pay;
            Talk talk;
            //*****************阿里产品
            abstractFactory = new AliFactory();
            pay = abstractFactory.CreatePay();
            pay.PayWay();

            talk = abstractFactory.CreakTalk();
            talk.TalkWay();
            //*****************微信产品
            Console.WriteLine();
            abstractFactory = new WeChatFactory();
            pay = abstractFactory.CreatePay();
            pay.PayWay();

            talk = abstractFactory.CreakTalk();
            talk.TalkWay();
            Console.ReadLine();
        }
    }
}

效果：

在现实的业务中，如果用到工厂方法，大大能增加业务的弹性。