設計模式理解

1. 簡單工廠模式：就是在一個單例里面通過傳入的值創建不同的對象

class ModuleFactory
    {
        public static Module CreateModuel(ModuleType type)
        {
            switch (type)
            {
                case ModuleType.A:
                    return new A();
                case ModuleType.B:
                    return new B();
                default:
                    throw new Exception("Wrong");
            }
        }
    }
    public enum ModuleType
    {
        A,B
    }
    public interface Module
    {

    }
    public class A:Module { }
    public class B : Module { }

View Code

優點：全局通過一個ModuleFactory.CreateModule 獲取Module下所有的類型，我程序用于緩存機制通過CacheFactory.Instance 獲取 redis 或者本地緩存。

缺點：1.新增一個 C類型，需要修改 ModuleFactory 里面的方法（可以用IOC緩解）

　　　2.Module如果新增一個新的方法，那么全局所有的子類都需要重寫，所以我建議可以用抽象類型代替，或者集成一個父類，且父類通過向后運行機制代替，而不用 interface

2. 工廠模式：通過interface來獲取不同的子類工廠，讓子類工廠各自創建需要的對象

public class FactoryConsole
    {
        Module module;
        public FactoryConsole()
        {
            ModuleFactory factory = new AModuleFactory();
            //factory = new BModuleFactory();
            module = factory.CreateModuel();
        }
        public void Console1()
        {
            module.ToString();
        }
        public void Console2()
        {
            module.ToString();
        }
        public void Console3()
        {
            module.ToString();
        }
    }
    public interface ModuleFactory
    {
        Module CreateModuel();
    }
    public class AModuleFactory : ModuleFactory
    {
        public Module CreateModuel()
        {
            return new A();
        }
    }
    public class BModuleFactory : ModuleFactory
    {
        public Module CreateModuel()
        {
            return new B();
        }
    }

View Code

優點：我只需要切換FactoryConsole里面初始化的值，到BModuleFactory，那么FactoryConsole底下全部的調用的地方都自動切換到了BModuleFactory，不需要一個個到固定的具體使用的方法里面，甚至我只需要將 AModuleFactory.CreateModuel 切換到B，那么全部使用CreateModuel的地方全部切換成了 BModule。

思考：

如果是想全局通過工廠模式切換，可以直接使用簡單工廠（不傳參數，改變返回的默認值，即可全部切換）。所以工廠模式是為了針對一個項目不同返回不同對象來處理業務的場景，這點非常重要，區別于單例，ps雖然簡單工廠基本上是單例
如果90%是固定的實現對象，剩余10%是單獨對象場景，注意固定實現對象的意思是，要切換都切換的場景，可以實現一個default工廠，此工廠為簡單工廠來實現，然后與單獨對象公用最外層工廠
IOC可以理解成是簡單工廠+工廠模式+單例模式的組成形式

3.抽象工廠模式：我認為此翻譯有誤，Abstract Factory Pattern 應該為工廠通過抽象的方法組合成新對象模式會更好點。

public interface AbstractFactory
    {
        Module Module();
        ModuleNew New();
    }
    public interface ModuleNew
    {

    }
    public class A1 : ModuleNew { }
    public class B1 : ModuleNew { }

View Code

多個父類在一個工廠里面組裝成需要的對方。

這也是此設計模式根本使用場景，也是為什么稱呼為創建型模式，其實也可以理解拆解，

比如包子拆解成面粉水餡 3個步驟，每個步驟都是一個工廠，如餡的工廠模式用牛肉就是牛肉包子，用豬肉就是豬肉包子。

所以抽象工廠模式，就是好幾個工廠在一個對象里面的組裝。而不是單獨的一個設計模式

4.橋接模式：非常類似工廠模式，但是目的不一樣，工廠返回的是所有內部實現的統一interface，目的只是為了與底層隔離，但是需要底層的功能，但是橋接模式目的是組裝，創建新的功能，并且內部是橋接多個不同的對象組成新對象，這個也是橋接模式是結構型設計模式，而工廠是創建型設計模式，橋接模式自己不產生底層對象，只是為了交互，一定與工廠模式區分開來。橋接模式只是為了粘合，功能使用，而工廠模式為了創建對象。典型區別，代碼展示了工廠和橋接

interface BridgeModule
    {
        void Shape(ModuleA a, ModuleB b);
    }
    public class Bridge : BridgeModule
    {
        public void Shape(ModuleA a, ModuleB b)
        {
            throw new NotImplementedException();
        }
        public void InitShape()
        {
            ModuleFactory moduleFactoryA = new AbstractModuleFactory();
            Shape(moduleFactoryA.CreateAModuel(), moduleFactoryA.CreateBModuel());
        }
    }
    public interface ModuleFactory
    {
        ModuleA CreateAModuel();
        ModuleB CreateBModuel();
    }
    public class AbstractModuleFactory : ModuleFactory
    {
        public ModuleA CreateAModuel()
        {
            throw new NotImplementedException();
        }

        public ModuleB CreateBModuel()
        {
            throw new NotImplementedException();
        }
    }
    public interface ModuleA
    {

    }
    public class A : ModuleA { }
    public class B : ModuleA { }
    public interface ModuleB
    {

    }
    public class C : ModuleB { }
    public class D : ModuleB { }

View Code

posted @ 2024-06-03 20:31 Best_Hong 閱讀(19) 評論(0) 收藏舉報

刷新頁面返回頂部

Best_Hong

設計模式理解

公告