設計模式培訓之三：抽象工廠

查看本人文章索引請通過http://www.cnblogs.com/seesea125/archive/2012/04/17/2453256.html

在工廠方法里講到了加減乘除的例子，請查閱http://www.cnblogs.com/seesea125/archive/2012/05/02/2478981.html

 

一、抽象工廠的定義

提供一個創建一系列相關或相互依賴對象的接口，而無須指定它們的具體類。

二、實現思路

實現思路：如果說簡單工廠與工廠方法是對同一個問題的兩種不同的解決方法的話，抽象工廠就是解決一系列這種問題的方法。因為其主要的作用就是生產一系列相互依賴的對象，而不用去關心它們具體的實現。

三、代碼實現

為了方便查看工廠方法和抽象工廠的區別，因此還以工廠方法的例子為例，做進一步擴展。

在工廠方法里，工廠方法的核心代碼如下：

public interface IFactory
    {
        Operation Create();
    }
    public class AddOperation : IFactory
    {
        public Operation Create()
        {
            return new OperationAdd();
        }
    }
    public class SubOperation : IFactory
    {
        public Operation Create()
        {
            return new OperationSub();
        }
    }

    public abstract class Operation
    {
        public double NumA { get; set; }
        public double NumB { get; set; }
        public abstract double GetResult();
    }
    public class OperationAdd : Operation
    {
        public override double GetResult()
        {
            return NumA + NumB;
        }
    }
    public class OperationSub : Operation
    {
        public override double GetResult()
        {
            return NumA - NumB;
        }
    }

 

假設這個加減運算是中國人的運算方法，美國人加減運算不是這么算的，比如美國人的加法，是NumA + NumB+10，美國人的減法是NumA - NumB-10，呵呵，這只是假設，目的是方便我們看工廠方法和抽象工廠的區別，當然現實中不可能發生。

為了區分，我們把OperationAdd，OperationSub 分別改為ChinaOperationAdd，ChinaOperationSub，同時實現美國人的加法和減法AmericaOperationAdd，AmericaOperationSub,這兩個方法也同樣繼承自Operation，代碼如下：

public abstract class Operation
    {
        public double NumA { get; set; }
        public double NumB { get; set; }
        public abstract double GetResult();
    }
    public class ChinaOperationAdd : Operation
    {
        public override double GetResult()
        {
            return NumA + NumB;
        }
    }
    public class ChinaOperationSub : Operation
    {
        public override double GetResult()
        {
            return NumA - NumB;
        }
    }

    public class AmericaOperationAdd : Operation
    {
        public override double GetResult()
        {
            return NumA + NumB+10;
        }
    }
    public class AmericaOperationSub : Operation
    {
        public override double GetResult()
        {
            return NumA - NumB-10;
        }
    }

 

接下來我們把AddOperation 和SubOperation 這兩個繼承自IFactory的類，給改造一下，定義一個新的類ChinaOperationFactroy，這個新類里返回兩個操作，分別是AddOperation，SubOperation，代碼如下：

public class ChinaOperationFactroy
    {
        public Operation AddOperation()
        {
            return new ChinaOperationAdd();
        }

        public Operation SubOperation()
        {
            return new ChinaOperationSub();
        }
    }

 

 

再建一個美國的工廠，也是返回美國的加法和減法的實例，代碼如下：

public class AmericaOperationFactroy
    {
        public Operation AddOperation()
        {
            return new AmericaOperationAdd();
        }

        public Operation SubOperation()
        {
            return new AmericaOperationSub();
        }
    }

 

到現在為止，ChinaOperationFactroy，AmericaOperationFactroy的代碼很相似，他們都是返回了AddOperation和SubOperation方法，因此把他們抽象出來，建議一個抽象工廠

public abstract class AbstractFactory
    {
        public static AbstractFactory GetInstance()
        {
            AbstractFactory instance = new AmericaOperationFactroy();
            return instance;
        }
        public abstract Operation AddOperation();
        public abstract Operation SubOperation();
    }

 

然后讓ChinaOperationFactroy和AmericaOperationFactroy繼承這個工廠，改進后代碼如下

public class ChinaOperationFactroy : AbstractFactory
    {
        public override Operation AddOperation()
        {
            return new ChinaOperationAdd();
        }

        public override Operation SubOperation()
        {
            return new ChinaOperationSub();
        }
    }

    public class AmericaOperationFactroy : AbstractFactory
    {
        public override Operation AddOperation()
        {
            return new AmericaOperationAdd();
        }

        public override Operation SubOperation()
        {
            return new AmericaOperationSub();
        }
    }

 

 

此時抽象工廠已經完成了，客戶端調用

AbstractFactory af = AbstractFactory.GetInstance();
            Operation oper = af.AddOperation();
            oper.NumA = 3;
            oper.NumB = 2;
            double result = oper.GetResult();
            Response.Write(result);

 

這個時候如果我們想調用中國的加法和減法，只需要把抽象地方改下，改動一個標紅的地方即可，改動后，加法和減法運算都變成中國的了

public abstract class AbstractFactory
    {
        public static AbstractFactory GetInstance()
        {
            AbstractFactory instance = new ChinaOperationFactroy();
            return instance;
        }
        public abstract Operation AddOperation();
        public abstract Operation SubOperation();
    }

 

這種改動可以通過反射來搞定它，這樣就只需要修改配置文件就可以了，反射在工廠方法里已經介紹，就不再多寫了。

四、工廠與抽象工廠的對比

由代碼也可以看出，抽象工廠解決的是創 建一系列有共同風格的產品（魯菜還是粵菜），而工廠方法模式解決的創建有共同特征的一系列產品（紅燒肉、清蒸魚它們都是食物）。