讲解C#设计模式编程中享元模式的运用

发表于 | 更新于
本文字数： 4.2k | 阅读时长 ≈ 4 分钟

思考并回答以下问题：

概述

在软件开发中，我们有时需要创建大量细粒度的对象，比如文档处理系统就可能需要创建成千上万的字母对象。但如果对每个字母对象都分配内存，那么在系统运行时就会耗费大量的内存。如何在保留面向对象操作方式优点的同时避免创建大量的对象呢？这就到了享元模式发挥作用的时候了。

享元模式

享元模式运用共享技术有效地支持大量细粒度的对象。例如可以对文档处理系统创建共享池，在共享池中建立字母和代码的对应关系，这样就可以用共享池中的26个对象解决需要创建大量对象的问题。其结构图如下：

  • Flyweight定义了享元接口，外部对象通过这个接口来访问具体的享元对象。
  • ConcreteFlyweight实现Flyweight接口，定义了具体的享元对象，并保存享元对象的内部状态。该享元对象是可共享的。
  • UnsharedConcreteFlyweight实现Flyweight接口，定义了不用于共享的享元对象。
  • FlyweightFactory创建并管理享元对象。
  • Client保存对享元接口的引用，通过该引用有效的使用具体的享元对象。

示例

下面以一个实际的应用来实现下享元模式。这个例子是：一个文本编辑器中会出现很多字母，使用享元模式去实现这个文本编辑器的话，会把每个字母做成一个享元对象。享元对象的内部状态就是这个字母，而字母在文本中的位置和字体风格等其他信息就是它的外部状态。下面就以这个例子来实现下享元模式，具体实现代码如下：

Client.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/// <summary>
/// 客户端调用
/// </summary>
class Client
{
    static void Main(string[] args)
    {
        // 定义外部状态，例如字母的位置等信息
        int externalstate = 10;

        // 初始化享元工厂
        FlyweightFactory factory = new FlyweightFactory();

        // 判断是否已经创建了字母A，如果已经创建就直接使用创建的对象A
        Flyweight fa = factory.GetFlyweight("A");

        if (fa != null)
        {
            // 把外部状态作为享元对象的方法调用参数
            fa.Operation(--externalstate);
        }

        // 判断是否已经创建了字母B
        Flyweight fb = factory.GetFlyweight("B");
        if (fb != null)
        {
            fb.Operation(--externalstate);
        }

        // 判断是否已经创建了字母C
        Flyweight fc = factory.GetFlyweight("C");
        if (fc != null)
        {
            fc.Operation(--externalstate);
        }

        // 判断是否已经创建了字母D
        Flyweight fd= factory.GetFlyweight("D");
        if (fd != null)
        {
            fd.Operation(--externalstate);
        }
        else
        {
            Console.WriteLine("驻留池中不存在字符串D");
            // 这时候就需要创建一个对象并放入驻留池中
            ConcreteFlyweight d = new ConcreteFlyweight("D");
            factory.flyweights.Add("D", d);
        }
        Console.Read();
    }
}

FlyweightFactory.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/// <summary>
/// 享元工厂，负责创建和管理享元对象
/// </summary>
public class FlyweightFactory
{
    // 最好使用泛型Dictionary<string, Flyweighy>
    // public Dictionary<string, Flyweight> flyweights = new Dictionary<string, Flyweight>();
    public Hashtable flyweights = new Hashtable();

    public FlyweightFactory()
    {
        flyweights.Add("A", new ConcreteFlyweight("A"));
        flyweights.Add("B", new ConcreteFlyweight("B"));
        flyweights.Add("C", new ConcreteFlyweight("C"));
    }

    public Flyweight GetFlyweight(string key)
    {
        // 更好的实现如下
        // Flyweight flyweight = flyweights[key] as Flyweight;
        // if (flyweight == null)
        // {
        //     Console.WriteLine("驻留池中不存在字符串" + key);
        //     flyweight = new ConcreteFlyweight(key);
        // }
        // return flyweight;
        return flyweights[key] as Flyweight;
    }
}

Flyweight.cs

1
2
3
4
5
6
7
/// <summary>
/// 抽象享元类，提供具体享元类具有的方法
/// </summary>
public abstract class Flyweight
{
    public abstract void Operation(int extrinsicstate);
}

ConcreteFlyweight.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 具体的享元对象，这样我们不把每个字母设计成一个单独的类了，而是作为把共享的字母作为享元对象的内部状态
public class ConcreteFlyweight : Flyweight
{
    // 内部状态
    private string intrinsicstate;

    // 构造函数
    public ConcreteFlyweight(string innerState)
    {
        this.intrinsicstate = innerState;
    }

    /// <summary>
    /// 享元类的实例方法
    /// </summary>
    /// <param name="extrinsicstate">外部状态</param>
    public override void Operation(int extrinsicstate)
    {
        Console.WriteLine("具体实现类: intrinsicstate {0}, extrinsicstate {1}", intrinsicstate, extrinsicstate);
    }
}

在享元模式的实现中，我们没有像之前一样，把一个细粒度的类实例设计成一个单独的类，而是把它作为共享对象的内部状态放在共享类的内部定义。

享元模式的优缺点

分析完享元模式的实现之后，让我们继续分析下享元模式的优缺点：

优点：

降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

缺点：

  • 1.为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑更复杂，使系统复杂化。
  • 2.享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

使用场景

在下面所有条件都满足时，可以考虑使用享元模式：

  • 一个系统中有大量的对象；
  • 这些对象耗费大量的内存；
  • 这些对象中的状态大部分都可以被外部化；
  • 这些对象可以按照内部状态分成很多的组，当把外部对象从对象中剔除时，每一个组都可以仅用一个对象代替；
  • 软件系统不依赖这些对象的身份。

满足上面的条件的系统可以使用享元模式。但是使用享元模式需要额外维护一个记录子系统已有的所有享元的表，而这也需要耗费资源，所以，应当在有足够多的享元实例可共享时才值得使用享元模式。

0%