設計模式一 - Simple Factory, Factory Method, Abstract Factory以及Builder模式簡述

2019-11-17 03:50:16

字體：大中小

來源：轉載

供稿：網友

雖然現在博客園上關于設計模式的文章已經有很多，但還是寫一篇來湊下熱鬧，也算是對自己多這幾種模式得使用總結。

Factory Pattern 工廠模式和 Builder Patter 建造者模式都是通過定義接口來將類的定義和實現區分開來。下面一步一步來做說明

1. Simple Factory 簡單工廠

簡單工廠只是將類簡單抽象化，以Pizza為例，我們定義好Pizza的接口，實現繼承Pizza的類PizzaA和PizzaB，然后簡單工廠提供方法根據傳進來的參數類型確定像調用者返回PizzaA或者PizzaB的實例

代碼
    public interface Pizza
    {
        void DoPizza();
    }

    public class PizzaA : Pizza
    {
        public void DoPizza()
        {
            Console.WriteLine("pizza A");
        }
    }

    public class PizzaB : Pizza
    {
        public void DoPizza()
        {
            Console.WriteLine("pizza B");
        }
    }
   public static class SimplePizzaFacotry
    {
        public static Pizza Create(string type)
        {
            if (type == "PizzaA")
                return new PizzaA();
            else
                return new PizzaB();
        }
    }

    // Usage
    public class SimplePizzaFacotryOrder
    {
        public void OrderPizza()
        {
            Pizza pizza = SimplePizzaFacotry.Create("PizzaA");
            pizza.DoPizza();
        }
    }

2. Factory Method工廠方法

工廠方式是在簡單工廠模式基礎上進一步抽象來符合OO設計的要求。這里將Factory抽象化為接口或抽象類，然后繼承類負責具體實現。此時增加一個FactoryManage來負責返回那個工廠類實現的實例。代碼示例如下

代碼
// Pizza, PizzaA, PizzaB繼續使用簡單工廠定義

    public abstract class PizzaFactory
    {
        public abstract Pizza Create();
    }

    public class PizzaAFactory : PizzaFactory
    {
        public override Pizza Create()
        {
            return new PizzaA();
            //throw new NotImplementedException();
        }
    }

    public class PizzaBFactory : PizzaFactory
    {
        public override Pizza Create()
        {
            return new PizzaB();
            //throw new NotImplementedException();
        }
    }

    public abstract class PizzaMethodManager
    {
        public static PizzaFactory Factory = new PizzaAFactory();
    }

    //usage
    public class FactoryMethodPizzaOrder
    {
        public FactoryMethodPizzaOrder()
        {
            Pizza pizza = PizzaMethodManager.Factory.Create();
        }
    }

  3. Abstract Factory 抽象工廠

抽象工廠和工廠方法基本上一樣，區別在于此時抽象工廠可以來實現一系列相關類的實現。繼續用Pizza舉例，這里將Pizza分為Dough和Sauce即面團和醬，然后定義HutPizza和PapaPizza的面團Dougn, Sauce以及Pizza的實現。示例如下

代碼
    public interface IDough
    {
       void DoDough();
    }

    public interface ISauce
    {
        void DoSauce();
    }

    public class PapaDough : IDough
    {
        public void DoDough()
        {
            Console.WriteLine("Papa Jone's Dough");
        }
    }

    public class PapaSource : ISauce
    {
        public void DoSauce()
        {
            Console.WriteLine("Papa Jone's Sauce");
        }
    }

    public class HutDough : IDough
    {
        public void DoDough()
        {
            Console.WriteLine("Pizza Hut's Dough");
        }
    }

    public class HutSource : ISauce
    {
        public void DoSauce()
        {
            Console.WriteLine("Pizza Hut's Sauce");
        }
    }

    public interface ipizzaFactory
    {
        IDough PRepareDough();
        ISauce AddSauce();
    }

    public class PapaPizzaFacotry : IPizzaFactory
    {
        public IDough PrepareDough()
        {
            return new PapaDough();
        }

        public ISauce AddSauce()
        {
            return new PapaSource();
        }
    }

    public class HutPizzaFacotry : IPizzaFactory
    {
        public IDough PrepareDough()
        {
            return new HutDough();
        }

        public ISauce AddSauce()
        {
            return new HutSource();
        }
    }

    public abstract class AbstractPizzaManager
    {
        public static IPizzaFactory Facotry = new PapaPizzaFacotry();
    }

    // Usage
    public class OrderPizzaAbstract
    {
        public void OrderPizza()
        {
            IDough dough = AbstractPizzaManager.Facotry.PrepareDough();
            ISauce sauce = AbstractPizzaManager.Facotry.AddSauce();
            dough.DoDough();
            sauce.DoSauce();
        }
    }



4. Builder Pattern 建造者模式

Builder和抽象工廠類似，也是建立一系列對象的實現。區別在于Builder建立的一對象有依賴關系而Factory的對象只是有關聯。依舊以Pizza為例，pizza的做法是先做面團(餅底)，然后放Sauce(Cheese或者其他的東西)，然后放Topping(火腿，香腸之類的)。舉例如下

代碼
    class PizzaBD
    {
        public string Dough { get; set; }
        public string Sauce { get; set; }
        public string Topping { get; set; }
    }

    abstract class PizzaBuilder
    {
        public PizzaBD pizza { get; protected set; }

        public void CreatePizza()
        {
            pizza = new PizzaBD();
        }

        public abstract void BuildDough();
        public abstract void BuildSauce();
        public abstract void BuildTopping();
    }

    class HawaiianPizzaBuilder : PizzaBuilder
    {
        public override void  BuildDough()
        {
            pizza.Dough = "Cross";
        }

        public override void BuildSauce()
        {
            pizza.Sauce = "Mild";
        }

        public override void BuildTopping()
        {
            pizza.Topping = "Ham+Pineapple";
        }
    }

    class SpicyPizzaBuilder : PizzaBuilder
    {
        public override void BuildDough()
        {
            pizza.Dough = "Pan Baked";
        }

        public override void BuildSauce()
        {
            pizza.Sauce = "Hot";
        }

        public override void BuildTopping()
        {
            pizza.Topping = "Pepperoni+Salami";
        }
    }

    class Cook
    {
        public PizzaBuilder PizzaBuilder { get; set; }

        public PizzaBD Pizza { get { return PizzaBuilder.pizza; } }

        public void MakePizza()
        {
            PizzaBuilder.CreatePizza();
            PizzaBuilder.BuildDough();
            PizzaBuilder.BuildSauce();
            PizzaBuilder.BuildTopping();
        }
    }

    // usage
    public class CallBuilder
    {
        public void OrderPizza()
        {
            Cook cook = new Cook();
            cook.PizzaBuilder = new SpicyPizzaBuilder();
            cook.MakePizza();
            cook.PizzaBuilder = new HawaiianPizzaBuilder();
            cook.MakePizza();
        }
    }

  5. Facade Pattern 外觀模式

提到了Builder模式，也就順便提一下Facade模式。兩者類似處在于都是建立一系列對象，區別在于Builder模式創建一系列有依賴關系的子類，而Facade模式則是建立一個將復雜的子類簡化和集中化的通道。還是以Pizza為例，客戶吃完付款，需要Waiter收取現金/卡，然后財務做賬/transfer之后打印發票，返回。對客戶來說后端多的一系列動作他并不關心，PizzaPayFacade提供給客戶一個Pay方法，方法里面完成這一系列的動作[可能包括類的實現]。代碼稍后提供。大家可以先參考First We try, then we trust的Facade說明的代碼示例 http://m.survivalescaperooms.com/zhenyulu/articles/55992.html

上一篇：wpf控件開發基礎(2) -屬性系統(1)

下一篇：使用MPLex實現語法高亮顯示的功能代碼解釋