设计模式理解

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 { }

优点：全局通过一个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();
        }
    }

优点：我只需要切换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 { }

多个父类在一个工厂里面组装成 需要的对方。

这也是 此设计模式根本使用场景，也是为什么称呼为创建型模式，其实也可以理解 拆解，

比如包子拆解成 面粉 水 馅 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 { }