設計模式(3) 抽象工廠模式

• 抽象工廠模式
• 優化抽象工廠
• 異步工廠

在學習抽象工廠模式前，先來回顧一下前面的簡單工廠和工廠方法模式。簡單工廠的職責非常簡單：構造某個實體類型，然後把實例作爲抽象類型返回；
工廠方法模式則進一步抽象出一個抽象的創建者和一個抽象的產品類型，而實際的執行過程是具體工廠創建具體的產品類型，具體工廠和具體產品類型都可以被抽象爲之前定義的抽象創建者和抽象產品類型，這種模式即便面對的是一個很龐大的具有複雜家族關係的類型系統，客戶程序在操作的過程中仍然可以基於抽象創建者獲得滿足某種抽象類型的產品實例。

但在很多場景下，需要創建的不是僅僅繼承自單個抽象類型的產品，它們本身就是多個具有一定依賴關係，但非同源的類型。

抽象工廠模式

抽象工廠模式可以應對這種情況，它能夠產生一系列具有相關依賴關係的類型。
Provide an interface for creating families of related or dependent objects.
— Design Patterns : Elements of Reusable Object-Oriented Software

抽象工廠可以返回一系列相關或相互依賴對象的接口。另外抽象工廠自身也需要一個接口，這個接口定義中包括返回那些相關對象接口的方法定義。

其UML類圖如下：

其中IProductA IProductB就是相關或相互依賴對象的接口，實體工廠會生產實現了這些接口的實體產品。IAbstractFactory是抽象工廠的接口，定義了生產IProductA、IProductB的方法。實體工廠自行決定如何實現抽象工廠接口定義的生產方法。

實現代碼：

public interface IProductA { };
public interface IProductB { };

public interface IAbstractFactory
{
    IProductA CreateProductA();
    IProductB CreateProductB();
}

public class ProductA1 : IProductA { }
public class ProductA2 : IProductA { }
public class ProductB1 : IProductB { }
public class ProductB2 : IProductB { }

public class ConcreteFactory1 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ProductA1();
    }

    public IProductB CreateProductB()
    {
        return new ProductB1();
    }
}

public class ConcreteFactory2 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ProductA2();
    }

    public IProductB CreateProductB()
    {
        return new ProductB2();
    }
}

調用：

[Test]
public void AbstractFactoryTest()
{
    IAbstractFactory factory = new ConcreteFactory1();
    IProductA productA = factory.CreateProductA();
    IProductB productB = factory.CreateProductB();

    Assert.AreEqual(typeof(ProductA1), productA.GetType());
    Assert.AreEqual(typeof(ProductB1), productB.GetType());
}

從調用端代碼可以發現一個問題，同前面工廠方法模式一樣，Client與某個具體工廠耦合在一起，所以這裏也可以採用依賴注入的方式“解決”這個問題，把這一步的處理推給上一層的調用端。

優化抽象工廠模式

這套基於經典的抽象工廠模式的代碼還有可以優化的地方：

• 首先具體工廠的代碼重複性太高，
• 另外具體工廠與具體的產品綁定，如果需要改變產品組合的方式，就得要麼修改具體工廠的代碼，要麼創建新的工廠，改動都很大。
• 還有個更嚴重的問題，如果要添加新的抽象產品，那麼從抽象工廠接口到每個具體實現都需要修改，幾乎是牽一髮動全身。

針對第一點的優化方案，可以提取出一個具體工廠共用的基類AbstractFactoryBase，讓它實現抽象接口的創建方法，如果某個工廠的Create方法比較特殊，可以重寫基類的Create方法。
但是基類工廠並不知道具體工廠要創建的是怎樣的產品組合，這可以在實例化具體工廠的時候傳遞一個抽象產品與具體產品的映射（可以是字典的形式），讓基類根據映射關係來運作，或者可以基於現成的IOC容器來配置這樣的映射。這樣第二個、第三個問題也就都迎刃而解了。
實現代碼如下：

public interface IAbstractFactoryWithMapper
{
    T Create<T>() where T : class;
}

public abstract class AbstractFactoryBase : IAbstractFactoryWithMapper
{
    protected IDictionary<Type, Type> mapper;
    public AbstractFactoryBase(IDictionary<Type, Type> mapper)
    {
        this.mapper = mapper;
    }

    public virtual T Create<T>() where T : class
    {
        if (mapper == null || mapper.Count == 0 || !mapper.ContainsKey(typeof(T)))
        {
            throw new ArgumentNullException();
        }
        Type targetType = mapper[typeof(T)];
        return (T)Activator.CreateInstance(targetType);
    }
}

public class ConcreteFactory : AbstractFactoryBase
{
    public ConcreteFactory(IDictionary<Type, Type> mapper) : base(mapper) { }
}

調用：

[Test]
public void AbstractFactoryWithMapperTest()
{
    IDictionary<Type, Type> dictionary = new Dictionary<Type, Type>();
    dictionary.Add(typeof(IProductA), typeof(ProductA1));
    dictionary.Add(typeof(IProductB), typeof(ProductB1));

    IAbstractFactoryWithMapper factory = new ConcreteFactory(dictionary);
    IProductA productA = factory.Create<IProductA>();
    IProductB productB = factory.Create<IProductB>();

    Assert.AreEqual(typeof(ProductA1), productA.GetType());
    Assert.AreEqual(typeof(ProductB1), productB.GetType());
}

異步工廠

有些時候工廠創建產品實例的過程比較複雜，或者涉及網絡、數據庫等外部資源的訪問，整體耗時較長；這種情況下，如果工廠支持異步調用，客戶程序就可以只向工廠發一個請求，然後接着幹別的事，等收到工廠創建完成的通知後再回來接着處理。
異步工廠實現：

public interface IProduct { };
public interface IFactory
{
    IProduct Create();
}

public interface IFactoryWithNotifier : IFactory
{
    void Create(Action<IProduct> callBack);
}

//實體結構部分
public class ConcreteProduct : IProduct { }
public class ConcreteFactory : IFactoryWithNotifier
{
    public IProduct Create() //同步構造
    {
        return new ConcreteProduct();
    }

    public void Create(Action<IProduct> callBack)  //異步構造
    {
        IProduct product = Create();
        callBack(product);
    }
}

//爲方便單元測試構造的訂閱者
public class Subscriber
{
    private IProduct product;
    public void SetProduct(IProduct product)
    {
        this.product = product;
    }

    public IProduct GetProduct()
    {
        return product;
    }
}

調用：

[Test]
public void AsyncFactoryTest()
{
    IFactoryWithNotifier factoryWithNotifier = new ConcreteFactory();
    Subscriber subscribe = new Subscriber();
    Action<IProduct> callback = new Action<IProduct>(subscribe.SetProduct);

    Assert.IsNull(subscribe.GetProduct());
    factoryWithNotifier.Create(callback);
    Assert.IsNotNull(subscribe.GetProduct());
}

參考書籍：
王翔著 《設計模式——基於C#的工程化實現及擴展》