0%

设计模式-结构型模式-享元模式

发表于 更新于 分类于

享元模式 - 结构型模式的轻量级共享

在软件设计中，享元模式是一种结构型设计模式，它通过共享对象来减小系统中对象的数量，从而提高系统的性能。本文将深入讨论享元模式的概念、实现方式以及在实际应用中的使用场景。

享元模式的概念

享元模式（Flyweight Pattern）是一种结构型设计模式，其核心思想是共享对象以减小系统中对象的数量。享元模式适用于大量相似对象的场景，通过共享内部状态，减小存储和对象创建的开销。

享元模式的 UML 类图

classDiagram
    class Flyweight {
        + Operation(state: int): void
    }

    class ConcreteFlyweight {
        + Operation(state: int): void
    }

    class UnsharedConcreteFlyweight {
        + Operation(state: int): void
    }

    class FlyweightFactory {
        - flyweights: Dictionary
        + GetFlyweight(key: int): Flyweight
    }

    Flyweight <|.. ConcreteFlyweight
    Flyweight <|.. UnsharedConcreteFlyweight
    FlyweightFactory --> Flyweight

享元模式的实现方式

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
using System;
using System.Collections.Generic;

// 抽象享元类
public abstract class Flyweight
{
    public abstract void Operation(int state);
}

// 具体享元类
public class ConcreteFlyweight : Flyweight
{
    public override void Operation(int state)
    {
        Console.WriteLine($"Concrete Flyweight Operation with state: {state}");
    }
}

// 不共享的具体享元类
public class UnsharedConcreteFlyweight : Flyweight
{
    public override void Operation(int state)
    {
        Console.WriteLine($"Unshared Concrete Flyweight Operation with state: {state}");
    }
}

// 享元工厂类
public class FlyweightFactory
{
    private Dictionary<int, Flyweight> flyweights = new Dictionary<int, Flyweight>();

    public Flyweight GetFlyweight(int key)
    {
        if (flyweights.ContainsKey(key))
        {
            return flyweights[key];
        }
        else
        {
            Flyweight flyweight = new ConcreteFlyweight();
            flyweights.Add(key, flyweight);
            return flyweight;
        }
    }
}

享元模式的应用场景

享元模式适用于以下情况：

  1. 系统中存在大量相似对象，占用大量内存。
  2. 对象的状态可以外部状态和内部状态，外部状态可以在对象被创建后进行修改。
  3. 系统中的对象可以被共享，且客户端可以忽略对象的具体状态。

享元模式的优势

  1. 减小内存占用： 享元模式通过共享内部状态，减小系统中对象的数量，从而减小内存占用。
  2. 提高性能： 由于减少了对象的数量，系统性能得到提升，特别在需要大量创建相似对象的场景中。
  3. 灵活性： 享元模式将对象的状态分为内部状态和外部状态，外部状态可以在对象被创建后进行修改，提高了灵活性。

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Program
{
    static void Main()
    {
        // 创建享元工厂对象
        FlyweightFactory factory = new FlyweightFactory();

        // 获取共享的具体享元对象
        Flyweight flyweight1 = factory.GetFlyweight(1);

        // 调用具体享元对象的操作方法，实际上会共享相同的对象
        flyweight1.Operation(10);

        // 获取不共享的具体享元对象
        Flyweight flyweight2 = new UnsharedConcreteFlyweight();

        // 调用不共享的具体享元对象的操作方法
        flyweight2.Operation(20);
    }
}

总结

享元模式是一种结构型设计模式，通过共享内部状态以减小系统中对象的数量，提高系统性能。享元模式适用于大量相似对象的场景，通过共享内部状态，减小存储和对象创建的开销。在实际应用中，享元模式需要权衡共享状态和非共享状态的管理，确保系统的灵活性和可维护性。