首页 GameFramework

# IObjectPool

泛型 接口
- Register (T obj,bool spawned) 创建对象
- CanSpawn () 检查对象 - CanSpawn (string name) 检查对象 - T Spawn () 获取对象 - T Spawn (string name) 获取对象 - void UnSpawn (T obj) 回收对象 - void Unspawn (object target) 回收对象 - SetLocked (T obj,bool locked) 设置对象是否加锁 - SetLocked (object target,bool locked) 设置对象是否被加锁 - void SetPriority (T obj, int priority); 设置优先级 - void SetPriority (object target, int priority); 设置优先级 - bool ReleaseObject (T obj); 释放对象 - bool ReleaseObject (object target); 释放对象 - void Release (); 释放对象池 - void Release (int toReleaseCount); 释放指定数量

# 说下 ObjectPoolManager.Object

这个文件里面主要写了对象池里的对象主要的存取逻辑

往上抽象一层会有 ObjectPoolManager.ObjectPool 内部类如下:

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
/// <summary>
        /// 内部对象。
        /// </summary>
        /// <typeparam name="T">对象类型。</typeparam>
        private sealed class Object<T> : IReference where T : ObjectBase
        {
            private T m_Object;
            private int m_SpawnCount;

            /// <summary>
            /// 初始化内部对象的新实例。
            /// </summary>
            public Object()
            {
                m_Object = null;
                m_SpawnCount = 0;
            }

            /// <summary>
            /// 获取对象名称。
            /// </summary>
            public string Name
            {
                get
                {
                    return m_Object.Name;
                }
            }

            /// <summary>
            /// 获取对象是否被加锁。
            /// </summary>
            public bool Locked
            {
                get
                {
                    return m_Object.Locked;
                }
                internal set
                {
                    m_Object.Locked = value;
                }
            }

            /// <summary>
            /// 获取对象的优先级。
            /// </summary>
            public int Priority
            {
                get
                {
                    return m_Object.Priority;
                }
                internal set
                {
                    m_Object.Priority = value;
                }
            }

            /// <summary>
            /// 获取自定义释放检查标记。
            /// </summary>
            public bool CustomCanReleaseFlag
            {
                get
                {
                    return m_Object.CustomCanReleaseFlag;
                }
            }

            /// <summary>
            /// 获取对象上次使用时间。
            /// </summary>
            public DateTime LastUseTime
            {
                get
                {
                    return m_Object.LastUseTime;
                }
            }

            /// <summary>
            /// 获取对象是否正在使用。
            /// </summary>
            public bool IsInUse
            {
                get
                {
                    return m_SpawnCount > 0;
                }
            }

            /// <summary>
            /// 获取对象的获取计数。
            /// </summary>
            public int SpawnCount
            {
                get
                {
                    return m_SpawnCount;
                }
            }

            /// <summary>
            /// 创建内部对象。
            /// </summary>
            /// <param name="obj">对象。</param>
            /// <param name="spawned">对象是否已被获取。</param>
            /// <returns>创建的内部对象。</returns>
            public static Object<T> Create(T obj, bool spawned)
            {
                if (obj == null)
                {
                    throw new GameFrameworkException("Object is invalid.");
                }

                Object<T> internalObject = ReferencePool.Acquire<Object<T>>();
                internalObject.m_Object = obj;
                internalObject.m_SpawnCount = spawned ? 1 : 0;
                if (spawned)
                {
                    obj.OnSpawn();
                }

                return internalObject;
            }

            /// <summary>
            /// 清理内部对象。
            /// </summary>
            public void Clear()
            {
                m_Object = null;
                m_SpawnCount = 0;
            }

            /// <summary>
            /// 查看对象。
            /// </summary>
            /// <returns>对象。</returns>
            public T Peek()
            {
                return m_Object;
            }

            /// <summary>
            /// 获取对象。
            /// </summary>
            /// <returns>对象。</returns>
            public T Spawn()
            {
                m_SpawnCount++;
                m_Object.LastUseTime = DateTime.UtcNow;
                m_Object.OnSpawn();
                return m_Object;
            }

            /// <summary>
            /// 回收对象。
            /// </summary>
            public void Unspawn()
            {
                m_Object.OnUnspawn();
                m_Object.LastUseTime = DateTime.UtcNow;
                m_SpawnCount--;
                if (m_SpawnCount < 0)
                {
                    throw new GameFrameworkException(Utility.Text.Format("Object '{0}' spawn count is less than 0.", Name));
                }
            }

            /// <summary>
            /// 释放对象。
            /// </summary>
            /// <param name="isShutdown">是否是关闭对象池时触发。</param>
            public void Release(bool isShutdown)
            {
                m_Object.Release(isShutdown);
                ReferencePool.Release(m_Object);
            }
        }

m_Object 是对应的对象实例 SpawnCount 是生成次数 Name: 对象名称
Locked: 当前对象是否上锁 Priority: 当前对象的优先级
CustomCanReleaseFlag: 自定义释放检查的标记
LastUseTime: 对象上次使用的时间
IsInUse: 是否正在使用

函数部分
Create (T obj,bool spawned)
创建内部对象，这个函数在上级的调用里是经过 ObjectPool 进行调用的，具体的实现：先从依赖池里获取一个该泛型类型的依赖对象 (就是该 Object). 然后赋值主要参数 (实际对象和是否已经生成), 之后再调用对象的 OnSpawn 方法

Clear () 清理内部对象 Peek () 查看对象 Spawn () 获取对象
调用这个函数后使用计数器 + 1, 然后更新最后使用时间，同时调用 OnSpawn 方法 (可以理解为类似于初始化) Release () 释放，同时需要处理是否是关闭对象池时触发的。

# 再说下 ObjectPoolManager.ObjectPool

这个子实现是实现管理 Object 的 对象池，通过这个池对对象进行存取，池内维护对象列表

# 最后是 ObjectPoolManager

这个使用来控制对象池的 为什么要分这么细呢，其实主要是因为职责分离开了 本质业务是降低频繁创建对象带来的消耗，所以 Object 类是必要的。因为池子的需求所以需要一个控制 Object 生成与创建的 ObjectPool, 但同时对象池的泛用性又需要得到保证，所以就需要一个可以通过类型获取对象池的管理器，并且通过 Unity 的生命周期对对象池的实现进行维护的 ObjectPoolManager

# 简单的结构图

# 但是其中又用到了 ReferencePool

即依赖池，这个后续需要看一下