C# 设计模式：第八章 - 结构型模式之桥接模式（Bridge Pattern）

caifox

1035人浏览 · 2025-01-02 20:06:13

caifox · 2025-01-02 20:06:13 发布

欢迎来到 C# 设计模式 的第八章！在这一章中，我们将深入探讨 桥接模式（Bridge Pattern）。桥接模式是一种结构型设计模式，它将一个类的抽象部分与它的实现部分分离，使它们可以独立变化。想象一下，你有一辆汽车，但你想让它能够适应不同的引擎类型——汽油引擎、柴油引擎、甚至是电动引擎。为了实现这个功能，你可以使用桥接模式将汽车的“驾驶行为”与“引擎类型”分离开来，使得你可以轻松地为不同类型的引擎编写代码，而不需要修改汽车的其他部分。

第一节：什么是桥接模式？

1. 概念：

桥接模式的核心思想是：将一个类的抽象部分与它的实现部分分离，使它们可以独立变化。换句话说，桥接模式允许你将一个复杂系统的不同方面解耦，从而使得每个方面都可以独立地进行扩展和修改。这不仅提高了代码的灵活性，还减少了类之间的依赖关系。

幽默小贴士：

桥接模式就像是编程世界里的“变形金刚”，你可以通过它将不同的模块组合在一起，形成各种各样的形态。就像《变形金刚》中的汽车人一样，他们可以通过不同的模块组合，变成汽车、飞机甚至机器人！ 🚗➡️🤖

2. 为什么需要桥接模式？

减少类的数量：如果你在一个系统中有多个抽象类和多个实现类，并且它们之间存在复杂的组合关系，那么类的数量将会迅速增加。桥接模式通过将抽象部分与实现部分分离，减少了类的数量，使得代码更加简洁和易于维护。
支持多态性：桥接模式允许你在运行时动态地选择不同的实现类，而不需要硬编码具体的类名。你可以根据不同的条件选择不同的实现，从而使代码更加灵活。
提高可扩展性：桥接模式使得抽象部分和实现部分可以独立变化。这意味着你可以轻松地为系统添加新的抽象类或实现类，而不需要修改现有的代码。
降低耦合度：通过将抽象部分与实现部分分离，桥接模式降低了类之间的耦合度，使得系统的各个部分更加独立，更容易进行测试和维护。

第二节：真实案例

1. 远程控制设备：

假设你正在开发一个智能家居控制系统，用户可以通过遥控器控制不同的设备，如电视、音响、空调等。每种设备都有不同的品牌和型号，因此它们的控制方式也有所不同。为了实现这个功能，你可以使用桥接模式将“遥控器的行为”与“设备的具体实现”分离开来。这样，你可以轻松地为不同品牌的设备编写控制逻辑，而不需要修改遥控器的其他部分。

幽默小贴士：

在智能家居控制系统中，桥接模式就像是“万能遥控器”，它可以控制各种不同品牌的设备，而不需要为每个设备编写单独的遥控器。就像《回到未来》中的德洛里安汽车一样，你可以通过同一个遥控器控制任何设备，无论它是来自哪个时代！ 📺➡️📱

2. 图形绘制系统：

假设你在开发一个图形绘制系统，用户可以选择不同的形状（如圆形、矩形、三角形等），并且可以选择不同的绘制方式（如使用不同的颜色、线条粗细等）。为了实现这个功能，你可以使用桥接模式将“形状的绘制逻辑”与“具体的绘制实现”分离开来。这样，你可以轻松地为不同的形状编写绘制逻辑，而不需要为每种绘制方式编写单独的类。

幽默小贴士：

在图形绘制系统中，桥接模式就像是“魔法画笔”，它可以绘制各种不同的形状，而不需要为每个形状编写单独的绘制逻辑。就像《冰雪奇缘》中的艾莎女王一样，她可以通过同一支画笔绘制出不同的图案，让每一幅画都变得独一无二！ ✍️➡️🎨

第三节：实施方法

在 C# 中实现桥接模式通常涉及以下几个类：

IImplementation 接口：这是实现部分的接口，定义了所有实现类的公共行为。
ConcreteImplementationX 类：这是实现了 IImplementation 接口的具体实现类，代表不同的实现方式。
Abstraction 类：这是抽象部分的基类，持有一个对 IImplementation 对象的引用。抽象类负责定义抽象行为，并调用实现类的方法。
RefinedAbstraction 类：这是继承自 Abstraction 类的细化抽象类，它可以在父类的基础上进一步扩展或修改行为。
Client 类（客户端代码）：这是使用桥接模式的客户端代码。它通过创建抽象类和实现类的组合，来实现特定的功能。

第四节：类之间的关系

1. 所需的类

在实现桥接模式时，通常需要以下几个类：

IImplementation 接口：
- 这是实现部分的接口，定义了所有实现类的公共行为。所有的具体实现类都必须实现这个接口。
ConcreteImplementationX 类：
- 这是实现了 IImplementation 接口的具体实现类，代表不同的实现方式。每个具体实现类负责提供具体的实现逻辑。
Abstraction 类：
- 这是抽象部分的基类，持有一个对 IImplementation 对象的引用。抽象类负责定义抽象行为，并调用实现类的方法。
RefinedAbstraction 类：
- 这是继承自 Abstraction 类的细化抽象类，它可以在父类的基础上进一步扩展或修改行为。
Client 类（客户端代码）：
- 这是使用桥接模式的客户端代码。它通过创建抽象类和实现类的组合，来实现特定的功能。

2. 类的详细说明

1. `IImplementation` 接口

// 定义实现部分的接口
public interface IImplementation
{
    void Operation();
}

作用：IImplementation 接口是实现部分的接口，定义了所有实现类的公共行为。在这个例子中，我们定义了一个 Operation() 方法，用于执行某个操作。
优点：通过接口定义公共行为，可以支持多态性，允许客户端代码动态地选择不同的实现类。

2. `ConcreteImplementationX` 类

// 实现具体实现类 1
public class ConcreteImplementationA : IImplementation
{
    public void Operation()
    {
        Console.WriteLine("我是具体的实现 A，我执行了某种操作");
    }
}

// 实现具体实现类 2
public class ConcreteImplementationB : IImplementation
{
    public void Operation()
    {
        Console.WriteLine("我是具体的实现 B，我执行了另一种操作");
    }
}

作用：ConcreteImplementationA 和 ConcreteImplementationB 是实现了 IImplementation 接口的具体实现类，代表不同的实现方式。每个具体实现类负责提供具体的实现逻辑。
优点：通过实现不同的 Operation() 方法，具体实现类可以为不同的场景提供不同的实现方式。

3. `Abstraction` 类

// 定义抽象部分的基类
public abstract class Abstraction
{
    protected IImplementation _implementation;

    // 构造函数，传入实现对象
    public Abstraction(IImplementation implementation)
    {
        _implementation = implementation;
    }

    // 定义抽象行为
    public virtual void Operation()
    {
        _implementation.Operation();
    }
}

作用：Abstraction 类是抽象部分的基类，持有一个对 IImplementation 对象的引用。抽象类负责定义抽象行为，并调用实现类的方法。
优点：通过持有对实现类的引用，抽象类可以在不修改现有代码的情况下，轻松地为不同的实现类提供支持。

4. `RefinedAbstraction` 类

// 继承自抽象类的细化抽象类
public class RefinedAbstraction : Abstraction
{
    public RefinedAbstraction(IImplementation implementation) : base(implementation)
    {
    }

    // 重写抽象行为，添加额外的逻辑
    public override void Operation()
    {
        Console.WriteLine("我是细化的抽象类，在执行原有操作之前添加了一些逻辑");

        // 调用实现类的方法
        base.Operation();

        Console.WriteLine("我是细化的抽象类，在执行原有操作之后添加了一些逻辑");
    }
}

作用：RefinedAbstraction 类是继承自 Abstraction 类的细化抽象类，它可以在父类的基础上进一步扩展或修改行为。在这个例子中，我们在执行原有操作之前和之后添加了一些额外的逻辑。
优点：通过继承和重写，细化抽象类可以在不修改现有代码的情况下，轻松地为不同的场景提供更复杂的行为。

5. `Client` 类（客户端代码）

class Program
{
    static void Main(string[] args)
    {
        // 创建具体的实现对象 A
        IImplementation implementationA = new ConcreteImplementationA();

        // 创建抽象对象，并传入实现对象 A
        Abstraction abstraction = new RefinedAbstraction(implementationA);

        // 调用抽象对象的 Operation() 方法
        abstraction.Operation();

        // 创建具体的实现对象 B
        IImplementation implementationB = new ConcreteImplementationB();

        // 创建新的抽象对象，并传入实现对象 B
        abstraction = new RefinedAbstraction(implementationB);

        // 调用新的抽象对象的 Operation() 方法
        abstraction.Operation();
    }
}

作用：Client 类是使用桥接模式的客户端代码。它通过创建抽象类和实现类的组合，来实现特定的功能。在这个例子中，我们创建了两个不同的实现对象，并通过相同的抽象类来调用它们的 Operation() 方法。
优点：通过桥接模式，客户端代码可以在不修改现有代码的情况下，轻松地为不同的实现类提供支持。

3. 类之间的关系

现在我们已经了解了所有需要的类，接下来让我们通过类图来展示这些类之间的关系。

类图示例：

+-------------------+
|  IImplementation  |
+-------------------+
| + Operation()     |
+-------------------+
         ^
         |
+-------------------+       +-------------------+
| ConcreteImplement |       | ConcreteImplement |
| ationA            |       | ationB            |
+-------------------+       +-------------------+
| + Operation()     |       | + Operation()     |
+-------------------+       +-------------------+

+-------------------+
|     Abstraction   |
+-------------------+
| - _implementation: IImplementation |
| + Operation()     |
+-------------------+
         ^
         |
+-------------------+
| RefinedAbstraction|
+-------------------+
| + Operation()     |
+-------------------+

+-------------------+
|       Client      |
+-------------------+
| + Main(): void    |
+-------------------+

幽默小贴士：

类图就像是编程世界的“桥梁”，它展示了各个类之间的连接方式。IImplementation 是“桥的一端”，定义了所有实现类的公共行为。ConcreteImplementationA 和 ConcreteImplementationB 是“桥的具体支撑点”，提供了不同的实现逻辑。Abstraction 是“桥的另一端”，它持有一个对实现类的引用，并负责调用实现类的方法。RefinedAbstraction 是“桥上的装饰物”，它可以在不修改现有代码的情况下，为桥添加更多的功能。Client 是“过桥的人”，它只需要通过抽象类和实现类的组合，就能轻松地实现特定的功能。 🌉

第五节：程序执行与输出

让我们通过几个实际的代码示例来演示桥接模式的使用。

示例 1：基本桥接模式

using System;

// 定义实现部分的接口
public interface IImplementation
{
    void Operation();
}

// 实现具体实现类 1
public class ConcreteImplementationA : IImplementation
{
    public void Operation()
    {
        Console.WriteLine("我是具体的实现 A，我执行了某种操作");
    }
}

// 实现具体实现类 2
public class ConcreteImplementationB : IImplementation
{
    public void Operation()
    {
        Console.WriteLine("我是具体的实现 B，我执行了另一种操作");
    }
}

// 定义抽象部分的基类
public abstract class Abstraction
{
    protected IImplementation _implementation;

    // 构造函数，传入实现对象
    public Abstraction(IImplementation implementation)
    {
        _implementation = implementation;
    }

    // 定义抽象行为
    public virtual void Operation()
    {
        _implementation.Operation();
    }
}

// 继承自抽象类的细化抽象类
public class RefinedAbstraction : Abstraction
{
    public RefinedAbstraction(IImplementation implementation) : base(implementation)
    {
    }

    // 重写抽象行为，添加额外的逻辑
    public override void Operation()
    {
        Console.WriteLine("我是细化的抽象类，在执行原有操作之前添加了一些逻辑");

        // 调用实现类的方法
        base.Operation();

        Console.WriteLine("我是细化的抽象类，在执行原有操作之后添加了一些逻辑");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建具体的实现对象 A
        IImplementation implementationA = new ConcreteImplementationA();

        // 创建抽象对象，并传入实现对象 A
        Abstraction abstraction = new RefinedAbstraction(implementationA);

        // 调用抽象对象的 Operation() 方法
        abstraction.Operation();

        // 创建具体的实现对象 B
        IImplementation implementationB = new ConcreteImplementationB();

        // 创建新的抽象对象，并传入实现对象 B
        abstraction = new RefinedAbstraction(implementationB);

        // 调用新的抽象对象的 Operation() 方法
        abstraction.Operation();
    }
}

输出结果：

我是细化的抽象类，在执行原有操作之前添加了一些逻辑
我是具体的实现 A，我执行了某种操作
我是细化的抽象类，在执行原有操作之后添加了一些逻辑
我是细化的抽象类，在执行原有操作之前添加了一些逻辑
我是具体的实现 B，我执行了另一种操作
我是细化的抽象类，在执行原有操作之后添加了一些逻辑

代码分析：

我们首先创建了一个 ConcreteImplementationA 对象，它是具体实现类，提供了某种操作的实现。
然后，我们创建了一个 RefinedAbstraction 对象，并将 ConcreteImplementationA 作为参数传递给它。RefinedAbstraction 类持有一个对实现类的引用，并在执行原有操作之前和之后添加了一些额外的逻辑。
接下来，我们调用了 abstraction.Operation() 方法，执行了细化抽象类和具体实现类的组合操作。
然后，我们创建了一个 ConcreteImplementationB 对象，并再次创建了一个 RefinedAbstraction 对象，这次传入的是 ConcreteImplementationB。我们再次调用了 abstraction.Operation() 方法，执行了新的组合操作。

幽默小贴士：

基本桥接模式就像是“变形金刚”，你可以通过它将不同的模块组合在一起，形成各种各样的形态。就像《变形金刚》中的汽车人一样，他们可以通过不同的模块组合，变成汽车、飞机甚至机器人！ 🚗➡️🤖

示例 2：远程控制设备

using System;

// 定义设备接口
public interface IDevice
{
    void TurnOn();
    void TurnOff();
    void SetVolume(int volume);
}

// 实现具体设备类 1：电视
public class TV : IDevice
{
    public void TurnOn()
    {
        Console.WriteLine("电视已打开");
    }

    public void TurnOff()
    {
        Console.WriteLine("电视已关闭");
    }

    public void SetVolume(int volume)
    {
        Console.WriteLine($"电视音量设置为 {volume}");
    }
}

// 实现具体设备类 2：音响
public class AudioSystem : IDevice
{
    public void TurnOn()
    {
        Console.WriteLine("音响已打开");
    }

    public void TurnOff()
    {
        Console.WriteLine("音响已关闭");
    }

    public void SetVolume(int volume)
    {
        Console.WriteLine($"音响音量设置为 {volume}");
    }
}

// 定义遥控器抽象类
public abstract class RemoteControl
{
    protected IDevice _device;

    public RemoteControl(IDevice device)
    {
        _device = device;
    }

    public virtual void PowerButton()
    {
        if (_device != null)
        {
            _device.TurnOn();
        }
        else
        {
            Console.WriteLine("没有连接设备");
        }
    }

    public virtual void VolumeUp()
    {
        if (_device != null)
        {
            _device.SetVolume(10);
        }
        else
        {
            Console.WriteLine("没有连接设备");
        }
    }

    public virtual void VolumeDown()
    {
        if (_device != null)
        {
            _device.SetVolume(5);
        }
        else
        {
            Console.WriteLine("没有连接设备");
        }
    }
}

// 继承自遥控器抽象类的高级遥控器
public class AdvancedRemoteControl : RemoteControl
{
    public AdvancedRemoteControl(IDevice device) : base(device)
    {
    }

    public override void PowerButton()
    {
        Console.WriteLine("高级遥控器：按下电源按钮");

        // 调用父类的 PowerButton() 方法
        base.PowerButton();
    }

    public override void VolumeUp()
    {
        Console.WriteLine("高级遥控器：音量上调");

        // 调用父类的 VolumeUp() 方法
        base.VolumeUp();
    }

    public override void VolumeDown()
    {
        Console.WriteLine("高级遥控器：音量下调");

        // 调用父类的 VolumeDown() 方法
        base.VolumeDown();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建电视设备
        IDevice tv = new TV();

        // 创建普通遥控器，并传入电视设备
        RemoteControl remote = new RemoteControl(tv);

        // 使用普通遥控器控制电视
        remote.PowerButton();
        remote.VolumeUp();
        remote.VolumeDown();

        // 创建音响设备
        IDevice audioSystem = new AudioSystem();

        // 创建高级遥控器，并传入音响设备
        remote = new AdvancedRemoteControl(audioSystem);

        // 使用高级遥控器控制音响
        remote.PowerButton();
        remote.VolumeUp();
        remote.VolumeDown();
    }
}

输出结果：

电视已打开
电视音量设置为 10
电视音量设置为 5
高级遥控器：按下电源按钮
音响已打开
高级遥控器：音量上调
音响音量设置为 10
高级遥控器：音量下调
音响音量设置为 5

代码分析：

我们定义了一个 IDevice 接口，它定义了所有设备的公共行为，包括 TurnOn()、TurnOff() 和 SetVolume() 方法。
然后，我们实现了 TV 和 AudioSystem 两个具体设备类，分别代表电视和音响。每个具体设备类都实现了 IDevice 接口，并提供了具体的实现逻辑。
接下来，我们定义了一个 RemoteControl 抽象类，它持有一个对 IDevice 对象的引用，并定义了基本的遥控器行为，如 PowerButton()、VolumeUp() 和 VolumeDown() 方法。
最后，我们创建了一个 AdvancedRemoteControl 类，它继承自 RemoteControl 类，并在父类的基础上添加了额外的逻辑。例如，在按下电源按钮时，高级遥控器会先输出一条提示信息，然后再调用父类的 PowerButton() 方法。

幽默小贴士：

在远程控制设备的例子中，桥接模式就像是“万能遥控器”，它可以控制各种不同品牌的设备，而不需要为每个设备编写单独的遥控器。就像《回到未来》中的德洛里安汽车一样，你可以通过同一个遥控器控制任何设备，无论它是来自哪个时代！ 📺➡️📱

第六节：桥接模式的注意事项

虽然桥接模式（Bridge Pattern）是一种非常强大的设计模式，能够有效地分离抽象与实现，避免了类层次结构的爆炸，并提高了系统的灵活性和可扩展性，但在使用时也有一些需要注意的地方。为了避免潜在的问题，并确保代码的可维护性和性能，以下是几个关键点：

1. 避免过度拆分

适度抽象：桥接模式的核心思想是将抽象部分与实现部分分离，使得它们可以独立变化。然而，过度拆分可能会导致系统变得过于复杂，难以理解和维护。因此，在应用桥接模式时，应该仔细评估哪些部分确实需要分离，哪些部分可以保持在一起。
权衡复杂性：桥接模式适用于那些抽象和实现之间存在多种组合的情况。如果你的系统中抽象和实现的关系相对简单，或者变化较少，那么可能不需要引入桥接模式。过度使用桥接模式可能会增加不必要的复杂性，反而降低代码的可读性和可维护性。

幽默小贴士：

桥接模式就像是给你的代码搭了一座桥，但你不需要在每条河上都建一座桥。有时候，直接过河已经足够！ 🌊

2. 保持接口的稳定性

稳定抽象接口：桥接模式的一个重要特点是通过定义一个稳定的抽象接口来隔离变化的实现。因此，确保抽象接口的设计足够稳定非常重要。如果抽象接口频繁变化，那么所有依赖该接口的实现类都会受到影响，导致维护成本增加。
避免接口膨胀：在设计抽象接口时，尽量避免让接口变得过于庞大或复杂。接口应该只包含必要的方法和属性，过多的方法会导致接口难以维护，并且增加了实现类的负担。

幽默小贴士：

抽象接口应该是“坚固的桥梁”，它不应该轻易摇晃或改变。就像你在河上建桥时，桥的基础必须稳固，才能确保安全通行！ 🛣️

3. 合理选择实现类

按需实现：桥接模式允许你为同一个抽象接口提供多个不同的实现类。因此，在选择实现类时，应该根据具体的需求和场景进行合理的决策。不要为了追求灵活性而创建过多的实现类，这可能会导致代码难以维护。
考虑扩展性：在设计实现类时，考虑到未来可能的变化和扩展。你可以通过引入一些通用的实现类来处理常见的功能，同时保留足够的灵活性以应对未来的特殊需求。

幽默小贴士：

实现类就像是桥的不同路段，每一段路都有其特定的功能。你需要根据车辆的类型和行驶需求，选择合适的路段，而不是为每一辆车都建一条新路！ 🚗

4. 避免循环依赖

单向依赖：桥接模式的一个重要原则是保持抽象和实现之间的单向依赖关系。抽象类不应该依赖于具体的实现类，而实现类可以依赖于抽象类。这样可以确保系统的灵活性和可扩展性。
避免双向依赖：如果你在设计中不小心引入了双向依赖，即抽象类和实现类互相依赖，那么系统将会变得非常脆弱，难以维护。双向依赖会破坏桥接模式的优势，导致代码耦合度增加。

幽默小贴士：

桥接模式中的依赖关系应该是“单行道”，而不是“环形路”。你不想在桥上绕圈子，对吧？ 🔄

5. 考虑性能影响

减少间接调用开销：桥接模式通过引入中间层（即抽象类和实现类之间的桥梁）来分离变化的部分，但这可能会带来一定的性能开销。每次调用抽象类的方法时，实际上是在调用实现类的方法，这涉及到额外的间接调用。因此，在性能敏感的应用中，应该谨慎评估桥接模式的性能影响。
优化实现类：为了减少性能开销，可以在实现类中进行适当的优化。例如，可以通过缓存常用的结果、减少不必要的计算等方式来提高性能。

幽默小贴士：

桥接模式的性能就像是桥的通行速度，虽然桥的存在让你可以跨越障碍，但如果桥太长或太慢，也会影响整体效率。所以，要确保桥的设计既坚固又高效！ ⏱️

本章总结

在这章中，我们深入探讨了 桥接模式 的基本概念、应用场景、实现方法以及注意事项。桥接模式提供了一种将抽象部分与实现部分分离的方式，使得它们可以独立变化，从而避免了类层次结构的爆炸，并提高了系统的灵活性和可扩展性。

我们通过几个实际的代码示例展示了如何在 C# 中实现桥接模式，包括基本的桥接模式和更复杂的多实现场景。最后，我们还讨论了一些使用桥接模式时需要注意的地方，帮助你在实际开发中做出明智的选择。

关键点回顾：

分离抽象与实现：桥接模式的核心思想是将抽象部分与实现部分分离，使得它们可以独立变化。
避免过度拆分：在应用桥接模式时，应该仔细评估哪些部分确实需要分离，避免过度拆分导致系统复杂化。
保持接口的稳定性：确保抽象接口的设计足够稳定，避免频繁变化，从而降低维护成本。
合理选择实现类：根据具体需求选择合适的实现类，同时考虑到未来的扩展性。
避免循环依赖：保持抽象和实现之间的单向依赖关系，避免双向依赖导致系统脆弱。
考虑性能影响：在性能敏感的应用中，评估桥接模式的性能开销，并进行适当的优化。

幽默小贴士：

桥接模式就像是编程世界里的“跨河大桥”，它让你可以轻松地跨越抽象与实现之间的鸿沟，而不必担心两者的变化会影响彼此。就像《指环王》中的友谊之桥一样，它连接了不同种族的战士，共同对抗邪恶力量！ 🌉

结束语

亲爱的学员们，恭喜你完成了 C# 设计模式 的这一章！通过学习桥接模式，你已经掌握了如何通过分离抽象与实现来提高代码的灵活性和可扩展性。接下来，我们将继续探索更多的设计模式，帮助你编写更加优雅、灵活和可维护的代码。

天工造物局

北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台

更多推荐

deck.gl TripsLayer 出租车轨迹动画示例实战：从示例运行到着色器原理

TripsLayer 是 deck.gl 中用于渲染**随时间流动的轨迹动画**（如出租车行程、物流路径、迁徙路线）的核心图层。本文以仓库中的最小独立示例 [examples/website/trips](https://link.gitcode.com/i/1442af8f442f4cff39ff546e050fceb5) 为骨架，带你完成从安装依赖、启动应用、理解曼哈顿出租车数据格式，到深入

天工造物局

Foundry Anvil 中 eth_simulateV1 的 Blob 交易与 Blob Gas 字段规范化：原理、实现与测试验证

本篇技术指南以 [anvil-simulate-blob-transactions.md](https://link.gitcode.com/i/3d2ebe227262de169335eb290af80da8) 这条 changelog 条目为起点，深入剖析 Foundry Anvil 对 `eth_simulateV1` RPC 返回结果中 blob（EIP-4844）交易与 blob gas

天工造物局

LMCache CLI 实战：用 `lmcache kvcache clear` 管理运行中服务的 KV Cache 状态

本文是一份针对 LMCache 官方 CLI 命令 `lmcache kvcache` 的完整技术指南。该命令用于在**运行中的 LMCache 服务（MP HTTP server）**上管理 KV cache 状态，当前提供 `clear` 子命令，用于清空 L1（CPU 内存）层中缓存的全部 KV 数据。读完本文，你将掌握该命令的完整参数体系、退出码语义、终端/JSON/静默三种输出模式，并能

天工造物局

所有评论(0)

查看更多评论

caifox

@caifox

已为社区贡献8条内容

C# 设计模式：第八章 - 结构型模式 之 桥接模式（Bridge Pattern）

caifox

第一节：什么是桥接模式？

1. 概念：

幽默小贴士：

2. 为什么需要桥接模式？

第二节：真实案例

1. 远程控制设备：

幽默小贴士：

2. 图形绘制系统：

幽默小贴士：

第三节：实施方法

第四节：类之间的关系

1. 所需的类

2. 类的详细说明

1. IImplementation 接口

2. ConcreteImplementationX 类

3. Abstraction 类

4. RefinedAbstraction 类

5. Client 类（客户端代码）

3. 类之间的关系

类图示例：

幽默小贴士：

第五节：程序执行与输出

示例 1：基本桥接模式

输出结果：

代码分析：

幽默小贴士：

示例 2：远程控制设备

输出结果：

代码分析：

幽默小贴士：

第六节：桥接模式的注意事项

1. 避免过度拆分

幽默小贴士：

2. 保持接口的稳定性

幽默小贴士：

3. 合理选择实现类

幽默小贴士：

4. 避免循环依赖

幽默小贴士：

5. 考虑性能影响

幽默小贴士：

本章总结

关键点回顾：

幽默小贴士：

结束语

所有评论(0)

温馨提示：您尚未绑定手机号

caifox

C# 设计模式：第八章 - 结构型模式之桥接模式（Bridge Pattern）

1. `IImplementation` 接口

2. `ConcreteImplementationX` 类

3. `Abstraction` 类

4. `RefinedAbstraction` 类

5. `Client` 类（客户端代码）