重温设计模式 --- 享元模式

引言

享元模式是一种结构型设计模式，它允许你在消耗少量内存的情况下支持大量对象。如果你需要生成大量细粒度的类实例来表示数据，而这些实例除了几个参数外基本上都是相同的，那么你可以使用享元模式来 避免大量相似类的开销。

在享元模式中，有两种状态：内部状态和外部状态。内部状态是存储在享元对象内部的，而外部状态则是在享元对象外部存储的。在使用享元模式时，你可以共享内部状态，而将外部状态作为参数传递给享元对象。

抽象享元

1
2
3
4
5
// 抽象享元类
abstract class Flyweight
{
    public abstract void Operation(int extrinsicState);
}

具体享元

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 具体享元类
class ConcreteFlyweight : Flyweight
{
    private readonly string _intrinsicState;

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

    public override void Operation(int extrinsicState)
    {
        // 输出内部状态和外部状态
        Console.WriteLine("Intrinsic State = " + _intrinsicState);
        
        Console.WriteLine("Extrinsic State = " + extrinsicState);
    }
}

享元工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 享元工厂类
class FlyweightFactory
{
    private readonly Dictionary<string, Flyweight> _flyweights = new Dictionary<string, Flyweight>();

    public Flyweight GetFlyweight(string key)
    {
        if (_flyweights.ContainsKey(key))
        {
            // 如果已经存在该享元对象，则直接返回该对象
            return _flyweights[key];
        }
        else
        {
            // 如果不存在，则创建一个新的享元对象，并存储在对象池中
            var flyweight = new ConcreteFlyweight(key);
            
            _flyweights.Add(key, flyweight);
            
            return flyweight;
        }
    }
}

在这个例子中，我们创建了一个抽象的享元类Flyweight，一个具体的享元类ConcreteFlyweight和一个享元工厂类FlyweightFactory。

在FlyweightFactory中，我们使用了一个Dictionary来存储享元对象。在GetFlyweight方法中，我们首先检查Dictionary中是否已经存在了一个享元对象。如果存在，我们就返回这个对象。否则，我们就创建一个新的享元对象，并将其添加到Dictionary中。

可以这样调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
new FlyweightFactory();

Flyweight flyweight1 = factory.GetFlyweight("A");

flyweight1.Operation(1);

Flyweight flyweight2 = factory.GetFlyweight("B");

flyweight2.Operation(2);

Flyweight flyweight3 = factory.GetFlyweight("A");

flyweight3.Operation(3);

输出：

1
2
3
4
5
6
7
8

1

Intrinsic State = B
Extrinsic State = 2

Intrinsic State = A
Extrinsic State = 3

从输出中就可以看出，享元A的内部状态是共享的，Operation更新的只是外部状态。

结论

享元模式所带来的优势：

  • 相同对象只需要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。
  • 享元模式可以避免大量相似类的开销。在软件开发中，如果需要生成大量细粒度的类实例来表示数据，如果这些实例除了几个参数外基本上都是相同的，这时候就可以使用享元模式来大幅度减少需要实例化类的数量。
  • 享元模式可以提高系统资源的利用率。由于享元模式可以减少系统中对象的数量，因此可以减少系统资源的占用，提高系统的性能。