設計模式理解

Best_Hong發表於2024-06-03
設計模式

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

相關文章