值得永久收藏的 C# 设计模式套路

Posted 2021-12-18 dotNET跨平台

设计模式套路，第二弹。

在第一篇中，主要写了创造模式相关的几种套路。如果你是刚看到这个文章，建议你先去看看第一篇 传送门。

这一篇，我们说说结构模式相关的套路。

结构模式，主要作用是将类型、对象和其它内容放在一起，以创建更大的结构，同时，又可以保持高度的灵活性和最佳性能。

也是像上一篇一样，一个一个来说。

一、适配器模式

适配器这个名字非常好理解，就像我们充电器的插头，是用来协调两个不同的东东之间的通信，并让他们互相理解。

代码也很简单：

public class AnotherType

    public string GetAuthorInfo()
    
        return "I am WangPlus";
    

public interface IAdapter

    string GetInfo();

public class Adapter : IAdapter

    private readonly AnotherType _anotherType;
    public Adapter(AnotherType anotherType)
    
        _anotherType = anotherType;
    
    public string GetInfo()
    
        return _anotherType.GetAuthorInfo();
    

public class Example

    public void Test()
    
        var adapter = new Adapter(new AnotherType());
        Console.WriteLine(adapter.GetInfo());
    
    // result:
    // I am WangPlus

没想到吧？这样的代码经常写，居然也是个模式。所以呀，还是我上一篇提到的说法：先有内容，然后才有概念和标准。套路一直在，只是很多人不知道他叫什么。

二、桥模式

这个也好理解，就是在两个东西之间搭了一个桥。

正常使用时，是把实体类与接口和抽象分离开。有一个非常明显的好处，是几个实现可以使用不同的技术。

理解概念有点难，还是看代码：

public interface IBridgeType

    void GetInfo();

public class BridgeA : IBridgeType

    public void GetInfo()
    
        Console.WriteLine("I am WangPlus");
    

public class BridgeB : IBridgeType

    public void GetInfo()
    
        Console.WriteLine("I am another WangPlus");
    

public interface IBridge

    public IBridgeType bridgeType
    
        get;
        set;
    
    void GetInfo();

public class BridgeType : IBridge

    public IBridgeType bridgeType
    
        get;
        set;
    
    public void GetInfo()
    
        bridgeType.GetInfo();
    

public static class BridgeExample

    public static void Test()
    
        var bridgeType = new BridgeType();
        bridgeType.bridgeType = new BridgeA();
        bridgeType.GetInfo();
        bridgeType.bridgeType = new BridgeB();
        bridgeType.GetInfo();
    
    // result:
    // I am WangPlus
    // I am another WangPlus

BridgeA 和 BridgeA 是两个实现，这儿就是上面说的不同的技术，用不同的技术实现了同一个接口。然后通过 IBridge 桥接到一个实现中。

使用时，使用不同的实现，但用相同的结构进行调用。在有需要时，我们可以根据场景做出无数个 BridgeN ，来实现黑盒类似但白盒完全不同的实体。

三、复合模式

听着就大就复杂。没错，所有叫复合的东西，都会形成一个树状结构。这好像是编程中的一个默认约定？

复合设计模式，就是把对象放在一个更大的树状结构的对象中，以多层次结构来呈现对象，以统一方式处理对象。

看看这个复杂代码的套路：

public abstract class Mobile

    protected string Name;
    protected Mobile(string name)
    
        Name = name;
    
    public virtual void Add(Mobile mobile)
    
        throw new NotImplementedException();
    
    public virtual void GetTree(int indent)
    
        throw new NotImplementedException();
    

public class MobileMemory : Mobile

    public MobileMemory(string name) : base(name)  
    public override void GetTree(int indent)
    
        Console.WriteLine(new String('-', indent) + " " + Name);
    

public class MobileModel : Mobile

    private readonly List<Mobile> _mobiles = new List<Mobile>();
    public MobileModel(string name) : base(name)  
    public override void Add(Mobile mobile)
    
        _mobiles.Add(mobile);
    
    public override void GetTree(int indent)
    
        Console.WriteLine(new String('-', indent) + "+ " + Name);

        foreach (var mobile in _mobiles)
        
            mobile.GetTree(indent + 2);
        
    

public static class Example

    public static void Test()
    
        var brand = new MobileModel("IPhone");

        var model13 = new MobileModel("13Pro");
        var model12 = new MobileModel("12Pro");

        var memory512G = new MobileMemory("512G");
        var memory256G = new MobileMemory("256G");

        model13.Add(memory256G);
        model13.Add(memory512G);

        model12.Add(memory256G);
        model12.Add(memory512G);

        brand.Add(model12);
        brand.Add(model13);

        brand.GetTree(1);
    
    // result:
    // ---+ 12Pro
    // ----- 256G
    // ----- 512G
    // ---+ 13Pro
    // ----- 256G
    // ----- 512G

这个套路确实稍微有点复杂。补充解释一下：

• MobileMemory 和 MobileModel，是为了表现多种对象，没有特殊含义，里面的区别就是 GetTree() 里打印出来的字符不同。

• 需要清楚理解的部分是 MobileModel 里构建的 _mobiles，他是一个顶层抽象类的数组。

• 这个模式最重要的结构，是用抽象类去组织数据，用实体类去操作功能。

另外，如果你的开发功力够，在这个架构中，实体本身也可以是复合对象。

四、装饰模式

这也是一个常用的模式。通过对抽象或接口的扩展，来加入对象功能。

而且这个套路的代码特别好理解：

public interface IMobile

    public string Brand
    
        get;
    
    public string Model
    
        get;
    
    public abstract void GetInfo();

public class IPhone : IMobile

    public string Brand => "Apple";
    public string Model => "13Pro";
    public void GetInfo()
    
        Console.WriteLine(this.ToJson());
    

public class IPhoneWithMemory : IMobile

    private readonly IMobile _mobile;
    public IPhoneWithMemory(IMobile mobile)
    
        _mobile = mobile;
    

    public string Brand => "Apple";
    public string Model => "13Pro";
    public string Memory => "512G";
    public void GetInfo()
    
        Console.WriteLine(this.ToJson());
    

public static class Example

    public static void Test()
    
        var iphone = new IPhone();
        iphone.GetInfo();
        var iphoneWithMemory = new IPhoneWithMemory(iphone);
        iphoneWithMemory.GetInfo();
    
    // result:
    // "Brand":"Apple","Model":"13Pro"
    // "Brand":"Apple","Model":"13Pro","Memory":"512G"

从上边的 IMobile 接口开始，每一个实体都是对前一个实体的补充和完善。

这种写法，在团队项目中很常见，可以在确保不对别人的内容进行修改的基础上，扩展新的功能。不用改别人的代码，又能补充进去新的内容。有没有被爽到？

五、外观模式

这个模式名称起得不知所云。不过意思和代码倒是很简单，就是把其它的接口、类、框架等的复杂系统汇集起来，让人能简单使用。

代码一看就懂：

public class Facade

    private readonly Mobile _mobile;
    private readonly Laptop _laptop;
    public Facade(Mobile mobile, Laptop laptop)
    
        _mobile = mobile;
        _laptop = laptop;
    
    public void GetInfo()
    
        _mobile.GetInfo();
        _laptop.GetInfo();
    

public class Mobile

    public void GetInfo()
    
        Console.WriteLine("I am mobile");
    

public class Laptop

    public void GetInfo()
    
        Console.WriteLine("I am laptop");
    

public static class Example

    public static void Test()
    
        var mobile = new Mobile();
        var laptop = new Laptop();
        var facade = new Facade(mobile, laptop);
        facade.GetInfo();
    
    // result:
    // I am mobile
    // I am laptop

这个模式，在开发中也用得比较多。尤其在团队项目中，会经常用到，原因跟上面一样。

六、轻量级模式

嗯，就是轻的意思。这个轻，不是写的少，而是内存使用少。

所以这个模式的主要优势，就是节省内存。

这个模式没办法给出简单的套路。他本身是一种想法，是一种写在代码中的思想，而不是一个套路性的代码组。

我拿一段代码来说明一下：

public class Flyweight

    private readonly List<KeyValuePair<string, DemoClass>> _sharedObjects = new();
    public Flyweight()
    
        _sharedObjects.Add(new KeyValuePair<string, DemoClass>("A", new DemoClass()));
        _sharedObjects.Add(new KeyValuePair<string, DemoClass>("B", new DemoClass()));
    
    public DemoClass GetObject(string key)
    
        return _sharedObjects.SingleOrDefault(c => c.Key == key).Value;
    

public interface IDemoClass

    public void Operation(string name);

public class DemoClass : IDemoClass

    public void Operation(string name)
    
        Console.WriteLine(name);
    

public static class Example

    public static void Test()
    
        var flyweight = new Flyweight();
        flyweight.GetObject("A").Operation("Hello");
        flyweight.GetObject("B").Operation("I am WangPlus");

        var heavy = new DemoClass();
        heavy.Operation("Hello, I am WangPlus");
    
    // result:
    // 下面是轻量级模式
    // Hello
    // I am WangPlus
    // 下面是普通模式
    // Hello, I am WangPlus

在这段代码里，真正属于轻量级模式模式的其实只是里面的这一段：

private readonly List<KeyValuePair<string, DemoClass>> _sharedObjects = new();
    public Flyweight()
    
        _sharedObjects.Add(new KeyValuePair<string, DemoClass>("A", new DemoClass()));
        _sharedObjects.Add(new KeyValuePair<string, DemoClass>("B", new DemoClass()));
    

能理解吗？这一段主要是构造了一个集合，用来存放对象。后面调用对象时，是从这个集合里出来的。

这样写的好处，是如果对象很多，每次 new 会占用大量内存，而先期存储在一个集合中，会让这个内存占用变得小很多。

好吧，如果不理解，也没关系。在 Dotnet 的整个源码中，这样使用的也并不多。

所以这个模式属于一个可以意会的模式。而且事实上，现在的内存成本之低，已经很少需要这么费心了。

七、代理模式

这个模式也好理解，就是加了一个代理。通过中间类型来控制对于主类型的访问。

嗯，别担心，这个是有套路的。

public abstract class MainAbst

    public abstract void GetInfo();

public class MainClass : MainAbst

    public override void GetInfo()
    
        Console.WriteLine("I am WangPlus");
    

public class Proxy : MainAbst

    private MainClass _main;
    public Proxy(MainClass main)
    
        _main = main;
    
    public override void GetInfo()
    
        _main ?? = new MainClass();
        _main.GetInfo();
    

public static class ProxyExample

    public static void Test()
    
        var proxy = new Proxy(new MainClass());
        proxy.GetInfo();
    
    // result:
    // I am WangPlus

这个套路也容易懂。MainClass 是我们的主类，在执行一些特定的方法。加出了一个代理类 Proxy。外部调用时，通过 Proxy 来调用主类的方法，同时，如果有需要对主类的输入输出进行处理，可以在 Proxy 的方法里直接写。

又是一个团队协作会用到的模式，嘿嘿。

结构模式的套路就是这样了。

还有一类模式，是行为设计模式。咱们改天再写。

喜欢就来个三连，让更多人因你而受益