迈向简洁的旅程：模式(Pattern)，我们该如何接纳？

最新推荐文章于 2025-03-14 15:09:51 发布

Dongwoo Jeong

最新推荐文章于 2025-03-14 15:09:51 发布

阅读量1.1k

点赞数 32

文章标签：设计模式

本文链接：https://blog.csdn.net/2404_84768005/article/details/145556629

版权

设计方法论”这一理念已经发展成为一个庞大的学术领域。而我被认为是所谓设计方法论的主要倡导者之一。我对这一现象感到非常遗憾，并公开声明，我拒绝将设计方法论作为研究对象。因为我认为将设计实践与设计研究分开是荒谬的。事实上，那些只研究设计方法论而不进行设计实践的人，几乎总是失败的设计师。他们缺乏内在的生命力，失去了创造的欲望，或者从一开始就没有这种欲望。（Alexander，1971）

人们常说，设计模式(Design Patterns)是万能解决方案。

在OOP（面向对象编程，Object-Oriented Programming）出现后，GOF（四人组，Gang of Four）的设计模式书问世并成为某种福音书。

许多开发者在阅读模式书籍时，仅看结构图就开始编写代码，结果往往导致僵化的实现。

我们在学习设计方法和模式时，总是在“图式理解”和“实际经验”之间的鸿沟中摇摆不定。

正如亚历山大所说，将设计方法从设计实体中分离出来，最终只会谈论空洞的幻影。

其实，在讨论模式之前，我们可以谈论习语(Idiom)等其他内容，但这个话题留到以后再说。

本文我们将讨论设计模式。

（艾伦·凯2003年的电子邮件故事）

我们今天所讨论的模式是如何产生的？

通常我们认为的面向对象编程（OOP）起源于Simula，

但一般认为第一个提出这个概念的人是艾伦·凯（Alan Kay），他在1967年初使用了这个术语。

然而，艾伦·凯在2003年的采访中表示，

他所说的面向对象编程指的是

消息传递(Messaging)、封装(Encapsulation)、动态绑定(Dynamic Binding)。

但如果这样说，这并不是我们现在所理解的OOP概念。

那么，我们现在所理解的概念是从哪里来的呢？

（我们实际认知中的OOP概念）

目前我们使用的OOP概念是由格雷迪·布奇（Booch）提出的，并在此基础上扩展的。

OOP是一种逻辑构建组件，使用对象而非算法。
每个对象是某个类的实例。
类通过继承关系相互关联。

通常我们将其总结为三个要素：

封装(Encapsulation)、继承(Inheritance)、多态(Polymorphism)。

这就是我们常说的面向对象编程的起点。

随着这种面向对象编程方式迅速成为主流，一本伟大的编程经典诞生了。

那就是

GOF（四人组，Gang of Four）。

埃里希·伽玛（Erich Gamma）、理查德·赫尔姆（Richard Helm）、拉尔夫·约翰逊（Ralph Johnson）和约翰·弗利西德斯（John Vlissides）

撰写的《设计模式》成为了现代编程的经典之作。

GOF展示了23种设计模式，并将其分为三种类型：

三种类型：

创建型模式（Creational Pattern）- 结构型模式（Structural Pattern）- 行为型模式（Behavioral Pattern）

创建型模式(Creational Pattern)

与对象创建相关的模式。
提高对象创建过程的灵活性，便于代码维护。

示例：单例模式(Singleton Pattern)、抽象工厂模式(Abstract Factory Pattern)、建造者模式(Builder Pattern)、工厂方法模式(Factory Method Pattern)、原型模式(Prototype Pattern)。

结构型模式(Structural Pattern)

与程序结构相关的模式。
设计程序中的数据结构或接口结构。
通过组合类或对象形成更大的结构。

示例：适配器模式(Adapter Pattern)、桥接模式(Bridge Pattern)、组合模式(Composite Pattern)、装饰器模式(Decorator Pattern)、外观模式(Facade Pattern)、享元模式(Flyweight Pattern)、代理模式(Proxy Pattern)。

行为型模式(Behavioral Pattern)

将对象间的重复交互模式化。
关注对象间算法或责任分配。
最小化耦合度（解耦）。

示例：命令模式(Command Pattern)、解释器模式(Interpreter Pattern)、迭代器模式(Iterator Pattern)、中介者模式(Mediator Pattern)、备忘录模式(Memento Pattern)、观察者模式(Observer Pattern)、状态模式(State Pattern)、策略模式(Strategy Pattern)、模板方法模式(Template Method Pattern)、访问者模式(Visitor Pattern)。

这些例子引起了爆炸性的流行。

它们成为了OOP中解决问题的一种模板。

然而，随着这些模式的流行，滥用模式的问题也随之而来，

很多人开始把这些模式当作“公理”，而不是“前辈程序员的经验产物”。

本文旨在强调，编程模式不是“公理”，

而是“前辈程序员创造的通用工具”的观点。

了解模式确实可以增加应对问题的选择，

但重要的是如何解决当前面临的问题，

而不是死记硬背模式目录。

利用模式进行重构，

乔舒亚的名著中也提到以下内容：

“模式的结构图只是示例，而不是规范。它描述了我们最常见的实现方式。
因此，结构图很可能与你自己的实现方式有许多共同点，
但差异是不可避免的，甚至是可取的。至少你会根据你的领域更改参与者的名称。
在调整实现上的优缺点后，你的实现方式可能与结构图有很大不同。”
——John Vlissides

这是GOF作者之一约翰·弗利西德斯的话。

这句话的重点是什么？

也就是说，即使是同一个模式，也可以用多种方式实现。

让我们简单举个例子。

// 策略接口
interface IDiscountStrategy
{
    double ApplyDiscount(double price);
}

// 具体策略类 1
class FixedDiscountStrategy : IDiscountStrategy
{
    private double discountAmount;
    public FixedDiscountStrategy(double amount)
    {
        discountAmount = amount;
    }
    public double ApplyDiscount(double price)
    {
        return price - discountAmount;
    }
}

// 具体策略类 2
class PercentageDiscountStrategy : IDiscountStrategy
{
    private double discountRate;
    public PercentageDiscountStrategy(double rate)
    {
        discountRate = rate;
    }
    public double ApplyDiscount(double price)
    {
        return price * (1 - discountRate);
    }
}

// 上下文类
class ShoppingCart
{
    private IDiscountStrategy discountStrategy;

    public ShoppingCart(IDiscountStrategy strategy)
    {
        discountStrategy = strategy;
    }

    public double CalculateTotalPrice(double originalPrice)
    {
        return discountStrategy.ApplyDiscount(originalPrice);
    }
}

// 使用示例
ShoppingCart cart1 = new ShoppingCart(new FixedDiscountStrategy(1000));
ShoppingCart cart2 = new ShoppingCart(new PercentageDiscountStrategy(0.1));

Console.WriteLine($"Fixed Discount: {cart1.CalculateTotalPrice(10000)}"); // 固定折扣：9000
Console.WriteLine($"Percentage Discount: {cart2.CalculateTotalPrice(10000)}"); // 百分比折扣：9000

常见的策略模式(Strategy Pattern)。

让我们尝试应用Lambda表达式。

这样就不需要定义接口和具体实现类。

// 折扣策略委托（函数类型定义）
delegate double DiscountStrategy(double price);

// 上下文类
class ShoppingCart
{
    private DiscountStrategy discountStrategy;

    public ShoppingCart(DiscountStrategy strategy)
    {
        discountStrategy = strategy;
    }

    public double CalculateTotalPrice(double originalPrice)
    {
        return discountStrategy(originalPrice);
    }
}

// 使用示例（使用Lambda表达式直接定义策略）
ShoppingCart cart1 = new ShoppingCart(price => price - 1000); // 固定折扣策略（Lambda表达式）
ShoppingCart cart2 = new ShoppingCart(price => price * 0.9);   // 百分比折扣策略（Lambda表达式）

Console.WriteLine($"Fixed Discount (Lambda): {cart1.CalculateTotalPrice(10000)}"); // 固定折扣（Lambda）：9000
Console.WriteLine($"Percentage Discount (Lambda): {cart2.CalculateTotalPrice(10000)}"); // 百分比折扣（Lambda）：9000

代码量显著减少，各种策略可以用Lambda表达式轻松定义，
并且可以根据需要更加灵活地动态更改策略！

接下来，让我们尝试用Lambda表达式/方法引用(Method Reference)来实现命令模式(Command Pattern)。

// 命令接口
interface ICommand
{
    void Execute();
}

// 具体命令类 1
class LightOnCommand : ICommand
{
    private Light light;
    public LightOnCommand(Light light)
    {
        this.light = light;
    }
    public void Execute()
    {
        light.TurnOn();
    }
}

// 具体命令类 2
class LightOffCommand : ICommand
{
    private Light light;
    public LightOffCommand(Light light)
    {
        this.light = light;
    }
    public void Execute()
    {
        light.TurnOff();
    }
}

// 接收者类
class Light
{
    public void TurnOn() { Console.WriteLine("Light On"); }
    public void TurnOff() { Console.WriteLine("Light Off"); }
}

// 调用者类
class RemoteControl
{
    private ICommand onCommand;
    private ICommand offCommand;

    public RemoteControl(ICommand on, ICommand off)
    {
        this.onCommand = on;
        this.offCommand = off;
    }

    public void PressOnButton() { onCommand.Execute(); }
    public void PressOffButton() { offCommand.Execute(); }
}

// 使用示例
Light livingRoomLight = new Light();
RemoteControl remote = new RemoteControl(new LightOnCommand(livingRoomLight), new LightOffCommand(livingRoomLight));

remote.PressOnButton();  // Light On
remote.PressOffButton(); // Light Off

// 命令委托 (void 返回类型，无参数)
delegate void Command();

// 接收者类 (同上)
class Light
{
    public void TurnOn() { Console.WriteLine("Light On"); }
    public void TurnOff() { Console.WriteLine("Light Off"); }
}

// 调用者类
class RemoteControl
{
    private Command onCommand;
    private Command offCommand;

    public RemoteControl(Command on, Command off)
    {
        this.onCommand = on;
        this.offCommand = off;
    }

    public void PressOnButton() { onCommand(); }
    public void PressOffButton() { offCommand(); }
}

// 使用示例 (使用 Lambda 表达式、方法引用直接定义命令)
Light livingRoomLight = new Light();
RemoteControl remote = new RemoteControl(
    livingRoomLight.TurnOn,  // 方法引用 (替代 LightOnCommand)
    () => livingRoomLight.TurnOff() // Lambda 表达式 (替代 LightOffCommand)
);

remote.PressOnButton();  // Light On
remote.PressOffButton(); // Light Off

代码量显著减少，各种策略可以用Lambda表达式轻松定义，
并且可以根据需要更加灵活地动态更改策略！

接下来，让我们尝试用Lambda表达式/方法引用(Method Reference)来实现命令模式(Command Pattern)。

代码行数再次减少，各种命令可以通过方法引用轻松定义，
并且可以根据需要动态更改命令，变得更加灵活！

现在让我们实现工厂模式(Factory Pattern)。

// 产品接口
interface IProduct
{
    void DoSomething();
}

// 具体产品类 1
class ConcreteProductA : IProduct
{
    public void DoSomething() { Console.WriteLine("Product A"); }
}

// 具体产品类 2
class ConcreteProductB : IProduct
{
    public void DoSomething() { Console.WriteLine("Product B"); }
}

// 工厂接口
interface IFactory
{
    IProduct CreateProduct();
}

// 具体工厂类 1
class ConcreteFactoryA : IFactory
{
    public IProduct CreateProduct() { return new ConcreteProductA(); }
}

// 具体工厂类 2
class ConcreteFactoryB : IFactory
{
    public IProduct CreateProduct() { return new ConcreteProductB(); }
}

// 客户端代码
class Client
{
    public void UseProduct(IFactory factory)
    {
        IProduct product = factory.CreateProduct();
        product.DoSomething();
    }
}

// 使用示例
Client client = new Client();
client.UseProduct(new ConcreteFactoryA()); // Product A
client.UseProduct(new ConcreteFactoryB()); // Product B

（典型的工厂模式）

// 产品接口 (同上)
interface IProduct
{
    void DoSomething();
}

// 具体产品类 (同上)
class ConcreteProductA : IProduct
{
    public void DoSomething() { Console.WriteLine("Product A"); }
}

class ConcreteProductB : IProduct
{
    public void DoSomething() { Console.WriteLine("Product B"); }
}

// 工厂委托 (返回产品接口，无参数)
delegate IProduct ProductFactory();

// 工厂字典
class ProductFactoryDictionary
{
    private Dictionary<string, ProductFactory> factories = new Dictionary<string, ProductFactory>();

    public void RegisterFactory(string productName, ProductFactory factory)
    {
        factories.Add(productName, factory);
    }

    public IProduct CreateProduct(string productName)
    {
        if (factories.ContainsKey(productName))
        {
            return factories[productName]();
        }
        return null; // 或者异常处理
    }
}

// 客户端代码
class Client
{
    public void UseProduct(ProductFactoryDictionary factoryDict, string productName)
    {
        IProduct product = factoryDict.CreateProduct(productName);
        if (product != null)
        {
            product.DoSomething();
        }
    }
}

// 使用示例 (使用 Lambda 表达式注册工厂)
ProductFactoryDictionary factoryDict = new ProductFactoryDictionary();
factoryDict.RegisterFactory("A", () => new ConcreteProductA()); // 使用 Lambda 表达式注册工厂
factoryDict.RegisterFactory("B", () => new ConcreteProductB()); // 使用 Lambda 表达式注册工厂

Client client = new Client();
client.UseProduct(factoryDict, "A"); // Product A
client.UseProduct(factoryDict, "B"); // Product B

使用Lambda表达式和字典实现

使用字典可以在运行时动态注册和管理工厂，便于从配置文件或外部数据源读取工厂信息。

可以说变得更加灵活了。

看到这里，有人可能会问：

“你是想说使用Lambda表达式的方法就是正确答案吗？”