欢迎来到 C# 设计模式 的第十一章！在这一章中，我们将深入探讨 享元模式（Flyweight Pattern）。享元模式是一种结构型设计模式，它通过共享相同的数据来减少内存的使用。想象一下，你正在玩一个大型的在线游戏，游戏中有成千上万的敌人。如果每个敌人都占用大量的内存，那么游戏可能会变得非常卡顿。为了优化性能，你可以使用享元模式，让多个敌人共享相同的数据，从而减少内存的消耗。这样，游戏就可以流畅地运行，而不会因为内存不足而导致卡顿。

第一节：什么是享元模式？

1. 概念：

享元模式的核心思想是：通过共享相同的数据来减少内存的使用。享元模式适用于那些需要创建大量相似对象的场景。通过将对象的内在状态（即不变的数据）提取出来并共享，可以显著减少内存的消耗。每个对象只需要存储外在状态（即变化的数据），而内在状态则由外部管理并共享给所有对象。

幽默小贴士：

享元模式就像是编程世界里的“克隆工厂”，它可以通过共享相同的数据来创建多个“克隆人”。就像《星球大战》中的克隆士兵一样，虽然每个士兵看起来都不同，但它们实际上共享了相同的身体和装备，从而节省了大量的资源！ 🤖

2. 为什么需要享元模式？

  • 减少内存消耗：享元模式通过共享相同的数据，减少了内存的使用。这对于需要创建大量相似对象的场景非常有用，如图形界面、文本编辑器、游戏开发等。

  • 提高性能：通过减少内存的消耗，享元模式可以提高系统的性能。尤其是在处理大量对象时，享元模式可以显著减少内存分配和垃圾回收的开销，从而使系统更加高效。

  • 支持大规模数据处理：享元模式非常适合处理大规模数据。例如，在文本编辑器中，你可以使用享元模式来表示字符格式，从而避免为每个字符创建单独的对象。这不仅可以减少内存的消耗，还可以提高文本编辑器的性能。

  • 简化对象管理：享元模式将对象的内在状态和外在状态分离，使得对象的管理和维护变得更加简单。你只需要管理少量的享元对象，而不需要为每个对象都创建独立的实例。

第二节：真实案例

1. 文本编辑器中的字符格式：

想象一下，你正在开发一个文本编辑器，用户可以在文本中应用不同的格式，如字体、颜色、大小等。如果为每个字符都创建一个单独的对象来存储格式信息，那么当文本量很大时，内存的消耗将会非常大。为了优化内存使用，你可以使用享元模式，将相同的格式信息提取出来并共享给多个字符。例如，所有使用相同字体和颜色的字符都可以共享同一个格式对象，而每个字符只需要存储自己的位置和内容。

幽默小贴士：

在文本编辑器中，享元模式就像是“格式魔法”，它可以让多个字符共享相同的格式信息，而不需要为每个字符都创建独立的格式对象。就像《哈利·波特》中的魔法咒语一样，你可以用一个咒语来改变多个物体的颜色，而不需要对每个物体都施加一次咒语！ ✨

2. 游戏中的敌人：

假设你在开发一款大型多人在线角色扮演游戏（MMORPG），游戏中有成千上万的敌人。每个敌人都有自己的属性，如生命值、攻击力、防御力等。如果为每个敌人都创建一个独立的对象，那么内存的消耗将会非常大。为了优化内存使用，你可以使用享元模式，将敌人的公共属性（如外观、行为模式等）提取出来并共享给多个敌人。每个敌人只需要存储自己的独特属性（如当前位置、当前生命值等），而公共属性则由外部管理并共享给所有敌人。

幽默小贴士：

在游戏中，享元模式就像是“克隆军队”，它可以让多个敌人共享相同的外观和行为模式，而不需要为每个敌人都创建独立的对象。就像《星球大战》中的克隆士兵一样，虽然每个士兵看起来都不同，但它们实际上共享了相同的身体和装备，从而节省了大量的资源！ 🤖

第三节：实施方法

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

  1. IFlyweight 接口：这是享元对象的公共接口，定义了所有享元对象的公共行为。
  2. ConcreteFlyweight 类：这是实现了 IFlyweight 接口的具体享元类，负责存储内在状态（即不变的数据）。它可以通过外部传递的外在状态来执行操作。
  3. UnsharedConcreteFlyweight 类：这是不参与共享的享元类，它存储了所有的状态（包括内在状态和外在状态）。对于那些不能共享的对象，你可以使用这个类。
  4. FlyweightFactory 类：这是享元工厂类，负责管理享元对象的创建和共享。它确保相同的享元对象只被创建一次，并将其返回给客户端代码。
  5. Client 类（客户端代码）：这是使用享元模式的客户端代码。它通过调用 FlyweightFactory 类的方法来获取享元对象，并通过 IFlyweight 接口与这些对象进行交互。

第四节：类之间的关系

1. 所需的类

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

  1. IFlyweight 接口：

    • 这是享元对象的公共接口，定义了所有享元对象的公共行为。无论是共享的享元对象还是不共享的享元对象，都必须实现这个接口。

  2. ConcreteFlyweight 类：

    • 这是实现了 IFlyweight 接口的具体享元类，负责存储内在状态（即不变的数据）。它可以通过外部传递的外在状态来执行操作。

  3. UnsharedConcreteFlyweight 类：

    • 这是不参与共享的享元类，它存储了所有的状态（包括内在状态和外在状态）。对于那些不能共享的对象，你可以使用这个类。

  4. FlyweightFactory 类：

    • 这是享元工厂类，负责管理享元对象的创建和共享。它确保相同的享元对象只被创建一次，并将其返回给客户端代码。

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

    • 这是使用享元模式的客户端代码。它通过调用 FlyweightFactory 类的方法来获取享元对象，并通过 IFlyweight 接口与这些对象进行交互。
2. 类的详细说明
1. IFlyweight 接口
// 定义享元接口
public interface IFlyweight
{
    void Operation(string extrinsicState);
}
  • 作用：IFlyweight 是享元对象的公共接口，定义了所有享元对象的公共行为。无论是共享的享元对象还是不共享的享元对象，都必须实现这个接口。
  • 优点：通过接口定义公共行为，可以支持多态性，允许客户端代码动态地选择不同的享元对象。
2. ConcreteFlyweight 类
// 实现具体享元类
public class ConcreteFlyweight : IFlyweight
{
    private readonly string _intrinsicState;

    public ConcreteFlyweight(string intrinsicState)
    {
        _intrinsicState = intrinsicState;
    }

    // 实现 Operation() 方法，接收外在状态并执行操作
    public void Operation(string extrinsicState)
    {
        Console.WriteLine($"ConcreteFlyweight: 内在状态 {_intrinsicState}, 外在状态 {extrinsicState}");
    }
}
  • 作用：ConcreteFlyweight 是实现了 IFlyweight 接口的具体享元类，负责存储内在状态（即不变的数据）。它可以通过外部传递的外在状态来执行操作。
  • 优点：通过将内在状态提取出来并共享，可以显著减少内存的消耗。
3. UnsharedConcreteFlyweight 类
// 实现不共享的享元类
public class UnsharedConcreteFlyweight : IFlyweight
{
    private readonly string _allState;

    public UnsharedConcreteFlyweight(string allState)
    {
        _allState = allState;
    }

    // 实现 Operation() 方法，直接使用内部状态
    public void Operation(string extrinsicState)
    {
        Console.WriteLine($"UnsharedConcreteFlyweight: 状态 {_allState}");
    }
}
  • 作用：UnsharedConcreteFlyweight 是不参与共享的享元类，它存储了所有的状态（包括内在状态和外在状态）。对于那些不能共享的对象，你可以使用这个类。
  • 优点：对于那些不能共享的对象，仍然可以通过实现 IFlyweight 接口来保持一致性。
4. FlyweightFactory 类
using System.Collections.Generic;

// 享元工厂类
public class FlyweightFactory
{
    private readonly Dictionary<string, IFlyweight> _flyweights = new Dictionary<string, IFlyweight>();

    // 创建或获取享元对象
    public IFlyweight GetFlyweight(string intrinsicState)
    {
        if (!_flyweights.ContainsKey(intrinsicState))
        {
            Console.WriteLine($"FlyweightFactory: 创建新的享元对象，内在状态 {intrinsicState}");
            _flyweights[intrinsicState] = new ConcreteFlyweight(intrinsicState);
        }

        return _flyweights[intrinsicState];
    }

    // 获取享元对象的数量
    public int GetFlyweightCount()
    {
        return _flyweights.Count;
    }
}
  • 作用：FlyweightFactory 是享元工厂类，负责管理享元对象的创建和共享。它确保相同的享元对象只被创建一次，并将其返回给客户端代码。
  • 优点：通过工厂类管理享元对象，可以确保相同的对象只被创建一次，从而减少内存的消耗。
5. Client 类（客户端代码）
class Program
{
    static void Main(string[] args)
    {
        // 创建享元工厂
        FlyweightFactory factory = new FlyweightFactory();

        // 获取享元对象并执行操作
        IFlyweight flyweight1 = factory.GetFlyweight("A");
        flyweight1.Operation("外在状态 1");

        IFlyweight flyweight2 = factory.GetFlyweight("B");
        flyweight2.Operation("外在状态 2");

        IFlyweight flyweight3 = factory.GetFlyweight("A");
        flyweight3.Operation("外在状态 3");

        // 获取享元对象的数量
        Console.WriteLine($"享元对象的数量: {factory.GetFlyweightCount()}");
    }
}
  • 作用：Client 是使用享元模式的客户端代码。它通过调用 FlyweightFactory 类的方法来获取享元对象，并通过 IFlyweight 接口与这些对象进行交互。
  • 优点：通过享元模式，客户端代码可以更加简洁地与享元对象进行交互，而不必关心对象的创建和管理。
3. 类之间的关系

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

类图示例：
+---------------------------+
|     IFlyweight            |
+---------------------------+
| + Operation(string): void |
+---------------------------+
         ^
         |
+---------------------------+       +--------------------------+
| ConcreteFlyweight         |       | UnsharedConcreteFlyweight|
+---------------------------+       +--------------------------+
| - _intrinsicState: string | -     |  _allState: string       |
+---------------------------+       +--------------------------+
| + Operation(string): void | +     |  Operation(string): void |
+---------------------------+       +--------------------------+

+---------------------------+
|  FlyweightFactory         |
+---------------------------+
| - _flyweights: 
| Dictionary<string, IFlyweight> |
+---------------------------+
| + GetFlyweight(string):   |
|    IFlyweight             |
| + GetFlyweightCount(): int|
+---------------------------+

+---------------------------+
|      Client               |
+---------------------------+
| + Main(): void            |
+---------------------------+
幽默小贴士：

类图就像是编程世界的“家族合影”，它展示了各个类之间的关系。FlyweightFactory 是“家族的长者”，它负责管理所有的享元对象，并确保相同的对象只被创建一次。ConcreteFlyweight 和 UnsharedConcreteFlyweight 是“家族的成员”，它们分别代表共享的和不共享的享元对象。Client 是“家族的访客”，它只需要与长者互动，而不需要直接与家族中的其他成员打交道！ 🏠

第五节：程序执行与输出

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

示例 1：基本享元模式
using System;
using System.Collections.Generic;

// 定义享元接口
public interface IFlyweight
{
    void Operation(string extrinsicState);
}

// 实现具体享元类
public class ConcreteFlyweight : IFlyweight
{
    private readonly string _intrinsicState;

    public ConcreteFlyweight(string intrinsicState)
    {
        _intrinsicState = intrinsicState;
    }

    // 实现 Operation() 方法，接收外在状态并执行操作
    public void Operation(string extrinsicState)
    {
        Console.WriteLine($"ConcreteFlyweight: 内在状态 {_intrinsicState}, 外在状态 {extrinsicState}");
    }
}

// 实现不共享的享元类
public class UnsharedConcreteFlyweight : IFlyweight
{
    private readonly string _allState;

    public UnsharedConcreteFlyweight(string allState)
    {
        _allState = allState;
    }

    // 实现 Operation() 方法，直接使用内部状态
    public void Operation(string extrinsicState)
    {
        Console.WriteLine($"UnsharedConcreteFlyweight: 状态 {_allState}");
    }
}

// 享元工厂类
public class FlyweightFactory
{
    private readonly Dictionary<string, IFlyweight> _flyweights = new Dictionary<string, IFlyweight>();

    // 创建或获取享元对象
    public IFlyweight GetFlyweight(string intrinsicState)
    {
        if (!_flyweights.ContainsKey(intrinsicState))
        {
            Console.WriteLine($"FlyweightFactory: 创建新的享元对象，内在状态 {intrinsicState}");
            _flyweights[intrinsicState] = new ConcreteFlyweight(intrinsicState);
        }

        return _flyweights[intrinsicState];
    }

    // 获取享元对象的数量
    public int GetFlyweightCount()
    {
        return _flyweights.Count;
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建享元工厂
        FlyweightFactory factory = new FlyweightFactory();

        // 获取享元对象并执行操作
        IFlyweight flyweight1 = factory.GetFlyweight("A");
        flyweight1.Operation("外在状态 1");

        IFlyweight flyweight2 = factory.GetFlyweight("B");
        flyweight2.Operation("外在状态 2");

        IFlyweight flyweight3 = factory.GetFlyweight("A");
        flyweight3.Operation("外在状态 3");

        // 获取享元对象的数量
        Console.WriteLine($"享元对象的数量: {factory.GetFlyweightCount()}");

        // 使用不共享的享元对象
        IFlyweight unsharedFlyweight = new UnsharedConcreteFlyweight("唯一的状态");
        unsharedFlyweight.Operation("外在状态 4");
    }
}
输出结果：
FlyweightFactory: 创建新的享元对象，内在状态 A
ConcreteFlyweight: 内在状态 A, 外在状态 外在状态 1
FlyweightFactory: 创建新的享元对象，内在状态 B
ConcreteFlyweight: 内在状态 B, 外在状态 外在状态 2
ConcreteFlyweight: 内在状态 A, 外在状态 外在状态 3
享元对象的数量: 2
UnsharedConcreteFlyweight: 状态 唯一的状态
代码分析：
  • 我们首先定义了 IFlyweight 接口，它是所有享元对象的公共接口。
  • 然后，我们实现了 ConcreteFlyweight 类，它负责存储内在状态，并通过外部传递的外在状态来执行操作。
  • 接下来，我们实现了 UnsharedConcreteFlyweight 类，它存储了所有的状态（包括内在状态和外在状态），用于那些不能共享的对象。
  • 然后，我们创建了 FlyweightFactory 类，它负责管理享元对象的创建和共享。它确保相同的享元对象只被创建一次，并将其返回给客户端代码。
  • 最后，在 Main() 方法中，我们通过 FlyweightFactory 获取了多个享元对象，并通过 IFlyweight 接口与这些对象进行交互。可以看到，相同的享元对象只被创建了一次，而不同的外在状态可以通过参数传递给享元对象。
幽默小贴士：

基本享元模式就像是“克隆工厂”，它可以通过共享相同的数据来创建多个“克隆人”。就像《星球大战》中的克隆士兵一样，虽然每个士兵看起来都不同，但它们实际上共享了相同的身体和装备，从而节省了大量的资源！ 🤖

示例 2：文本编辑器中的字符格式
using System;
using System.Collections.Generic;

// 定义享元接口
public interface ICharacterFormat
{
    void Display(char character);
}

// 实现具体享元类
public class CharacterFormat : ICharacterFormat
{
    private readonly string _font;
    private readonly string _color;

    public CharacterFormat(string font, string color)
    {
        _font = font;
        _color = color;
    }

    // 实现 Display() 方法，显示字符及其格式
    public void Display(char character)
    {
        Console.WriteLine($"字符: {character}, 字体: {_font}, 颜色: {_color}");
    }
}

// 享元工厂类
public class CharacterFormatFactory
{
    private readonly Dictionary<(string, string), ICharacterFormat> _formats = new Dictionary<(string, string), ICharacterFormat>();

    // 创建或获取字符格式
    public ICharacterFormat GetFormat(string font, string color)
    {
        var key = (font, color);

        if (!_formats.ContainsKey(key))
        {
            Console.WriteLine($"CharacterFormatFactory: 创建新的字符格式，字体: {font}, 颜色: {color}");
            _formats[key] = new CharacterFormat(font, color);
        }

        return _formats[key];
    }

    // 获取字符格式的数量
    public int GetFormatCount()
    {
        return _formats.Count;
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建字符格式工厂
        CharacterFormatFactory factory = new CharacterFormatFactory();

        // 获取字符格式并显示字符
        ICharacterFormat format1 = factory.GetFormat("Arial", "Red");
        format1.Display('A');

        ICharacterFormat format2 = factory.GetFormat("Times New Roman", "Blue");
        format2.Display('B');

        ICharacterFormat format3 = factory.GetFormat("Arial", "Red");
        format3.Display('C');

        // 获取字符格式的数量
        Console.WriteLine($"字符格式的数量: {factory.GetFormatCount()}");
    }
}
输出结果：
CharacterFormatFactory: 创建新的字符格式，字体: Arial, 颜色: Red
字符: A, 字体: Arial, 颜色: Red
CharacterFormatFactory: 创建新的字符格式，字体: Times New Roman, 颜色: Blue
字符: B, 字体: Times New Roman, 颜色: Blue
字符: C, 字体: Arial, 颜色: Red
字符格式的数量: 2
代码分析：
  • 我们定义了 ICharacterFormat 接口，它是所有字符格式的公共接口。
  • 然后，我们实现了 CharacterFormat 类，它负责存储字符的字体和颜色，并通过 Display() 方法显示字符及其格式。
  • 接下来，我们创建了 CharacterFormatFactory 类，它负责管理字符格式的创建和共享。它确保相同的字符格式只被创建一次，并将其返回给客户端代码。
  • 最后，在 Main() 方法中，我们通过 CharacterFormatFactory 获取了多个字符格式，并通过 ICharacterFormat 接口与这些格式进行交互。可以看到，相同的字符格式只被创建了一次，而不同的字符可以通过参数传递给格式对象。
幽默小贴士：

在文本编辑器中，享元模式就像是“格式魔法”，它可以让多个字符共享相同的格式信息，而不需要为每个字符都创建独立的格式对象。就像《哈利·波特》中的魔法咒语一样，你可以用一个咒语来改变多个物体的颜色，而不需要对每个物体都施加一次咒语！ ✨

第六节：注意事项

虽然享元模式非常强大且灵活，但在使用时也有一些需要注意的地方。为了避免潜在的问题，并确保代码的可维护性和性能，以下是几个关键点：

1. 合理划分内在状态和外在状态

  • 明确内在状态：内在状态是指那些不会随对象的变化而改变的数据。你应该尽量将这些数据提取出来并共享给多个对象。例如，在文本编辑器中，字体和颜色可以作为内在状态，因为它们不会随着字符的位置或内容而改变。

  • 明确外在状态：外在状态是指那些会随对象的变化而改变的数据。你应该将这些数据传递给享元对象，而不是存储在对象内部。例如，在文本编辑器中，字符的位置和内容可以作为外在状态，因为它们会随着字符的不同而变化。

幽默小贴士：

内在状态和外在状态就像是“固定的角色”和“变化的情节”，内在状态是固定的，不会随时间改变；而外在状态则是变化的，会随着情节的发展而改变。就像《哈利·波特》中的邓布利多校长一样，他的身份是固定的（内在状态），但他所做的事情会随着故事的发展而变化（外在状态）！ 🧙‍♂️

2. 避免过度使用享元模式

  • 适度共享：享元模式的核心是通过共享相同的数据来减少内存的消耗。然而，过度使用享元模式可能会导致代码变得复杂，尤其是当你需要频繁地传递外在状态时。你应该根据实际需求，合理地选择哪些对象需要共享，哪些对象可以直接创建独立的实例。

  • 权衡性能与复杂度：虽然享元模式可以减少内存的消耗，但它也会增加代码的复杂度。你需要权衡性能和复杂度之间的关系，确保享元模式带来的好处大于它的复杂度。

幽默小贴士：

享元模式就像是“魔法药水”，它可以让你节省资源，但也需要谨慎使用。如果你喝得太多，可能会导致副作用！所以，要确保你只在真正需要的时候使用享元模式，而不要滥用它！ 🧪

3. 考虑线程安全

  • 线程安全问题：享元模式通常涉及到多个对象共享相同的数据。在多线程环境下，如果多个线程同时访问相同的享元对象，可能会导致线程安全问题。你应该确保享元对象的内在状态是不可变的（即不会被修改），或者使用适当的同步机制来保证线程安全。

  • 避免可变状态：为了确保线程安全，你应该尽量避免在享元对象中存储可变的状态。内在状态应该是不可变的，而外在状态应该通过参数传递给享元对象。

幽默小贴士：

享元对象应该是“坚不可摧的宝石”，它不应该被任何线程修改。就像《指环王》中的魔戒一样，它具有强大的力量，但只有极少数人能够使用它！ 🔥

本章总结

在这章中，我们学习了 享元模式 的基本概念、应用场景、实现方法以及注意事项。享元模式通过共享相同的数据来减少内存的使用，特别适用于需要创建大量相似对象的场景，如文本编辑器、游戏开发等。它不仅可以减少内存的消耗，还可以提高系统的性能。

我们通过两个实际的代码示例展示了如何在 C# 中实现享元模式，包括基本的享元模式和文本编辑器中的字符格式应用。最后，我们还讨论了一些使用享元模式时需要注意的地方，帮助你在实际开发中做出明智的选择。

关键点回顾：
  • 减少内存消耗：享元模式通过共享相同的数据，减少了内存的使用。这对于需要创建大量相似对象的场景非常有用。
  • 提高性能：通过减少内存的消耗，享元模式可以提高系统的性能。尤其是在处理大量对象时，享元模式可以显著减少内存分配和垃圾回收的开销。
  • 支持大规模数据处理：享元模式非常适合处理大规模数据。例如，在文本编辑器中，你可以使用享元模式来表示字符格式，从而避免为每个字符创建单独的对象。
  • 简化对象管理：享元模式将对象的内在状态和外在状态分离，使得对象的管理和维护变得更加简单。你只需要管理少量的享元对象，而不需要为每个对象都创建独立的实例。
  • 合理划分内在状态和外在状态：内在状态是指那些不会随对象的变化而改变的数据，应该尽量提取出来并共享；外在状态是指那些会随对象的变化而改变的数据，应该通过参数传递给享元对象。
  • 避免过度使用享元模式：你应该根据实际需求，合理地选择哪些对象需要共享，哪些对象可以直接创建独立的实例，避免过度使用享元模式导致代码变得复杂。
  • 考虑线程安全：在多线程环境下，你应该确保享元对象的内在状态是不可变的，或者使用适当的同步机制来保证线程安全。
# 前端 # 开发语言 # c# # 设计模式 # 享元模式 # 装饰器模式 # 适配器模式
Logo
天工造物局

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

更多推荐

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

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

avatar 天工造物局

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

avatar 天工造物局

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

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

avatar 天工造物局