ObjectPoolComponent.cs 47 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033
  1. //------------------------------------------------------------
  2. // Game Framework
  3. // Copyright © 2013-2021 loyalsoft. All rights reserved.
  4. // Homepage: http://www.game7000.com/
  5. // Feedback: http://www.game7000.com/
  6. //------------------------------------------------------------
  7. using GameFramework;
  8. using GameFramework.ObjectPool;
  9. using System;
  10. using System.Collections.Generic;
  11. using UnityEngine;
  12. namespace UnityGameFramework.Runtime
  13. {
  14. /// <summary>
  15. /// 对象池组件。
  16. /// </summary>
  17. [DisallowMultipleComponent]
  18. [AddComponentMenu("Game Framework/Object Pool")]
  19. public sealed class ObjectPoolComponent : GameFrameworkComponent
  20. {
  21. private IObjectPoolManager m_ObjectPoolManager = null;
  22. /// <summary>
  23. /// 获取对象池数量。
  24. /// </summary>
  25. public int Count
  26. {
  27. get
  28. {
  29. return m_ObjectPoolManager.Count;
  30. }
  31. }
  32. /// <summary>
  33. /// 游戏框架组件初始化。
  34. /// </summary>
  35. protected override void Awake()
  36. {
  37. base.Awake();
  38. m_ObjectPoolManager = GameFrameworkEntry.GetModule<IObjectPoolManager>();
  39. if (m_ObjectPoolManager == null)
  40. {
  41. Log.Fatal("Object pool manager is invalid.");
  42. return;
  43. }
  44. }
  45. private void Start()
  46. {
  47. }
  48. /// <summary>
  49. /// 检查是否存在对象池。
  50. /// </summary>
  51. /// <typeparam name="T">对象类型。</typeparam>
  52. /// <returns>是否存在对象池。</returns>
  53. public bool HasObjectPool<T>() where T : ObjectBase
  54. {
  55. return m_ObjectPoolManager.HasObjectPool<T>();
  56. }
  57. /// <summary>
  58. /// 检查是否存在对象池。
  59. /// </summary>
  60. /// <param name="objectType">对象类型。</param>
  61. /// <returns>是否存在对象池。</returns>
  62. public bool HasObjectPool(Type objectType)
  63. {
  64. return m_ObjectPoolManager.HasObjectPool(objectType);
  65. }
  66. /// <summary>
  67. /// 检查是否存在对象池。
  68. /// </summary>
  69. /// <typeparam name="T">对象类型。</typeparam>
  70. /// <param name="name">对象池名称。</param>
  71. /// <returns>是否存在对象池。</returns>
  72. public bool HasObjectPool<T>(string name) where T : ObjectBase
  73. {
  74. return m_ObjectPoolManager.HasObjectPool<T>(name);
  75. }
  76. /// <summary>
  77. /// 检查是否存在对象池。
  78. /// </summary>
  79. /// <param name="objectType">对象类型。</param>
  80. /// <param name="name">对象池名称。</param>
  81. /// <returns>是否存在对象池。</returns>
  82. public bool HasObjectPool(Type objectType, string name)
  83. {
  84. return m_ObjectPoolManager.HasObjectPool(objectType, name);
  85. }
  86. /// <summary>
  87. /// 检查是否存在对象池。
  88. /// </summary>
  89. /// <param name="condition">要检查的条件。</param>
  90. /// <returns>是否存在对象池。</returns>
  91. public bool HasObjectPool(Predicate<ObjectPoolBase> condition)
  92. {
  93. return m_ObjectPoolManager.HasObjectPool(condition);
  94. }
  95. /// <summary>
  96. /// 获取对象池。
  97. /// </summary>
  98. /// <typeparam name="T">对象类型。</typeparam>
  99. /// <returns>要获取的对象池。</returns>
  100. public IObjectPool<T> GetObjectPool<T>() where T : ObjectBase
  101. {
  102. return m_ObjectPoolManager.GetObjectPool<T>();
  103. }
  104. /// <summary>
  105. /// 获取对象池。
  106. /// </summary>
  107. /// <param name="objectType">对象类型。</param>
  108. /// <returns>要获取的对象池。</returns>
  109. public ObjectPoolBase GetObjectPool(Type objectType)
  110. {
  111. return m_ObjectPoolManager.GetObjectPool(objectType);
  112. }
  113. /// <summary>
  114. /// 获取对象池。
  115. /// </summary>
  116. /// <typeparam name="T">对象类型。</typeparam>
  117. /// <param name="name">对象池名称。</param>
  118. /// <returns>要获取的对象池。</returns>
  119. public IObjectPool<T> GetObjectPool<T>(string name) where T : ObjectBase
  120. {
  121. return m_ObjectPoolManager.GetObjectPool<T>(name);
  122. }
  123. /// <summary>
  124. /// 获取对象池。
  125. /// </summary>
  126. /// <param name="objectType">对象类型。</param>
  127. /// <param name="name">对象池名称。</param>
  128. /// <returns>要获取的对象池。</returns>
  129. public ObjectPoolBase GetObjectPool(Type objectType, string name)
  130. {
  131. return m_ObjectPoolManager.GetObjectPool(objectType, name);
  132. }
  133. /// <summary>
  134. /// 获取对象池。
  135. /// </summary>
  136. /// <param name="condition">要检查的条件。</param>
  137. /// <returns>要获取的对象池。</returns>
  138. public ObjectPoolBase GetObjectPool(Predicate<ObjectPoolBase> condition)
  139. {
  140. return m_ObjectPoolManager.GetObjectPool(condition);
  141. }
  142. /// <summary>
  143. /// 获取对象池。
  144. /// </summary>
  145. /// <param name="condition">要检查的条件。</param>
  146. /// <returns>要获取的对象池。</returns>
  147. public ObjectPoolBase[] GetObjectPools(Predicate<ObjectPoolBase> condition)
  148. {
  149. return m_ObjectPoolManager.GetObjectPools(condition);
  150. }
  151. /// <summary>
  152. /// 获取对象池。
  153. /// </summary>
  154. /// <param name="condition">要检查的条件。</param>
  155. /// <param name="results">要获取的对象池。</param>
  156. public void GetObjectPools(Predicate<ObjectPoolBase> condition, List<ObjectPoolBase> results)
  157. {
  158. m_ObjectPoolManager.GetObjectPools(condition, results);
  159. }
  160. /// <summary>
  161. /// 获取所有对象池。
  162. /// </summary>
  163. public ObjectPoolBase[] GetAllObjectPools()
  164. {
  165. return m_ObjectPoolManager.GetAllObjectPools();
  166. }
  167. /// <summary>
  168. /// 获取所有对象池。
  169. /// </summary>
  170. /// <param name="results">所有对象池。</param>
  171. public void GetAllObjectPools(List<ObjectPoolBase> results)
  172. {
  173. m_ObjectPoolManager.GetAllObjectPools(results);
  174. }
  175. /// <summary>
  176. /// 获取所有对象池。
  177. /// </summary>
  178. /// <param name="sort">是否根据对象池的优先级排序。</param>
  179. /// <returns>所有对象池。</returns>
  180. public ObjectPoolBase[] GetAllObjectPools(bool sort)
  181. {
  182. return m_ObjectPoolManager.GetAllObjectPools(sort);
  183. }
  184. /// <summary>
  185. /// 获取所有对象池。
  186. /// </summary>
  187. /// <param name="sort">是否根据对象池的优先级排序。</param>
  188. /// <param name="results">所有对象池。</param>
  189. public void GetAllObjectPools(bool sort, List<ObjectPoolBase> results)
  190. {
  191. m_ObjectPoolManager.GetAllObjectPools(sort, results);
  192. }
  193. /// <summary>
  194. /// 创建允许单次获取的对象池。
  195. /// </summary>
  196. /// <typeparam name="T">对象类型。</typeparam>
  197. /// <returns>要创建的允许单次获取的对象池。</returns>
  198. public IObjectPool<T> CreateSingleSpawnObjectPool<T>() where T : ObjectBase
  199. {
  200. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>();
  201. }
  202. /// <summary>
  203. /// 创建允许单次获取的对象池。
  204. /// </summary>
  205. /// <param name="objectType">对象类型。</param>
  206. /// <returns>要创建的允许单次获取的对象池。</returns>
  207. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType)
  208. {
  209. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType);
  210. }
  211. /// <summary>
  212. /// 创建允许单次获取的对象池。
  213. /// </summary>
  214. /// <typeparam name="T">对象类型。</typeparam>
  215. /// <param name="name">对象池名称。</param>
  216. /// <returns>要创建的允许单次获取的对象池。</returns>
  217. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name) where T : ObjectBase
  218. {
  219. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(name);
  220. }
  221. /// <summary>
  222. /// 创建允许单次获取的对象池。
  223. /// </summary>
  224. /// <param name="objectType">对象类型。</param>
  225. /// <param name="name">对象池名称。</param>
  226. /// <returns>要创建的允许单次获取的对象池。</returns>
  227. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name)
  228. {
  229. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, name);
  230. }
  231. /// <summary>
  232. /// 创建允许单次获取的对象池。
  233. /// </summary>
  234. /// <typeparam name="T">对象类型。</typeparam>
  235. /// <param name="capacity">对象池的容量。</param>
  236. /// <returns>要创建的允许单次获取的对象池。</returns>
  237. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity) where T : ObjectBase
  238. {
  239. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(capacity);
  240. }
  241. /// <summary>
  242. /// 创建允许单次获取的对象池。
  243. /// </summary>
  244. /// <param name="objectType">对象类型。</param>
  245. /// <param name="capacity">对象池的容量。</param>
  246. /// <returns>要创建的允许单次获取的对象池。</returns>
  247. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity)
  248. {
  249. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, capacity);
  250. }
  251. /// <summary>
  252. /// 创建允许单次获取的对象池。
  253. /// </summary>
  254. /// <typeparam name="T">对象类型。</typeparam>
  255. /// <param name="expireTime">对象池对象过期秒数。</param>
  256. /// <returns>要创建的允许单次获取的对象池。</returns>
  257. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(float expireTime) where T : ObjectBase
  258. {
  259. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(expireTime);
  260. }
  261. /// <summary>
  262. /// 创建允许单次获取的对象池。
  263. /// </summary>
  264. /// <param name="objectType">对象类型。</param>
  265. /// <param name="expireTime">对象池对象过期秒数。</param>
  266. /// <returns>要创建的允许单次获取的对象池。</returns>
  267. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime)
  268. {
  269. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, expireTime);
  270. }
  271. /// <summary>
  272. /// 创建允许单次获取的对象池。
  273. /// </summary>
  274. /// <typeparam name="T">对象类型。</typeparam>
  275. /// <param name="name">对象池名称。</param>
  276. /// <param name="capacity">对象池的容量。</param>
  277. /// <returns>要创建的允许单次获取的对象池。</returns>
  278. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity) where T : ObjectBase
  279. {
  280. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(name, capacity);
  281. }
  282. /// <summary>
  283. /// 创建允许单次获取的对象池。
  284. /// </summary>
  285. /// <param name="objectType">对象类型。</param>
  286. /// <param name="name">对象池名称。</param>
  287. /// <param name="capacity">对象池的容量。</param>
  288. /// <returns>要创建的允许单次获取的对象池。</returns>
  289. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity)
  290. {
  291. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, name, capacity);
  292. }
  293. /// <summary>
  294. /// 创建允许单次获取的对象池。
  295. /// </summary>
  296. /// <typeparam name="T">对象类型。</typeparam>
  297. /// <param name="name">对象池名称。</param>
  298. /// <param name="expireTime">对象池对象过期秒数。</param>
  299. /// <returns>要创建的允许单次获取的对象池。</returns>
  300. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float expireTime) where T : ObjectBase
  301. {
  302. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(name, expireTime);
  303. }
  304. /// <summary>
  305. /// 创建允许单次获取的对象池。
  306. /// </summary>
  307. /// <param name="objectType">对象类型。</param>
  308. /// <param name="name">对象池名称。</param>
  309. /// <param name="expireTime">对象池对象过期秒数。</param>
  310. /// <returns>要创建的允许单次获取的对象池。</returns>
  311. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime)
  312. {
  313. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, name, expireTime);
  314. }
  315. /// <summary>
  316. /// 创建允许单次获取的对象池。
  317. /// </summary>
  318. /// <typeparam name="T">对象类型。</typeparam>
  319. /// <param name="capacity">对象池的容量。</param>
  320. /// <param name="expireTime">对象池对象过期秒数。</param>
  321. /// <returns>要创建的允许单次获取的对象池。</returns>
  322. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, float expireTime) where T : ObjectBase
  323. {
  324. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(capacity, expireTime);
  325. }
  326. /// <summary>
  327. /// 创建允许单次获取的对象池。
  328. /// </summary>
  329. /// <param name="objectType">对象类型。</param>
  330. /// <param name="capacity">对象池的容量。</param>
  331. /// <param name="expireTime">对象池对象过期秒数。</param>
  332. /// <returns>要创建的允许单次获取的对象池。</returns>
  333. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime)
  334. {
  335. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, capacity, expireTime);
  336. }
  337. /// <summary>
  338. /// 创建允许单次获取的对象池。
  339. /// </summary>
  340. /// <typeparam name="T">对象类型。</typeparam>
  341. /// <param name="capacity">对象池的容量。</param>
  342. /// <param name="priority">对象池的优先级。</param>
  343. /// <returns>要创建的允许单次获取的对象池。</returns>
  344. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, int priority) where T : ObjectBase
  345. {
  346. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(capacity, priority);
  347. }
  348. /// <summary>
  349. /// 创建允许单次获取的对象池。
  350. /// </summary>
  351. /// <param name="objectType">对象类型。</param>
  352. /// <param name="capacity">对象池的容量。</param>
  353. /// <param name="priority">对象池的优先级。</param>
  354. /// <returns>要创建的允许单次获取的对象池。</returns>
  355. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, int priority)
  356. {
  357. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, capacity, priority);
  358. }
  359. /// <summary>
  360. /// 创建允许单次获取的对象池。
  361. /// </summary>
  362. /// <typeparam name="T">对象类型。</typeparam>
  363. /// <param name="expireTime">对象池对象过期秒数。</param>
  364. /// <param name="priority">对象池的优先级。</param>
  365. /// <returns>要创建的允许单次获取的对象池。</returns>
  366. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(float expireTime, int priority) where T : ObjectBase
  367. {
  368. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(expireTime, priority);
  369. }
  370. /// <summary>
  371. /// 创建允许单次获取的对象池。
  372. /// </summary>
  373. /// <param name="objectType">对象类型。</param>
  374. /// <param name="expireTime">对象池对象过期秒数。</param>
  375. /// <param name="priority">对象池的优先级。</param>
  376. /// <returns>要创建的允许单次获取的对象池。</returns>
  377. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime, int priority)
  378. {
  379. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, expireTime, priority);
  380. }
  381. /// <summary>
  382. /// 创建允许单次获取的对象池。
  383. /// </summary>
  384. /// <typeparam name="T">对象类型。</typeparam>
  385. /// <param name="name">对象池名称。</param>
  386. /// <param name="capacity">对象池的容量。</param>
  387. /// <param name="expireTime">对象池对象过期秒数。</param>
  388. /// <returns>要创建的允许单次获取的对象池。</returns>
  389. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, float expireTime) where T : ObjectBase
  390. {
  391. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(name, capacity, expireTime);
  392. }
  393. /// <summary>
  394. /// 创建允许单次获取的对象池。
  395. /// </summary>
  396. /// <param name="objectType">对象类型。</param>
  397. /// <param name="name">对象池名称。</param>
  398. /// <param name="capacity">对象池的容量。</param>
  399. /// <param name="expireTime">对象池对象过期秒数。</param>
  400. /// <returns>要创建的允许单次获取的对象池。</returns>
  401. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime)
  402. {
  403. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, name, capacity, expireTime);
  404. }
  405. /// <summary>
  406. /// 创建允许单次获取的对象池。
  407. /// </summary>
  408. /// <typeparam name="T">对象类型。</typeparam>
  409. /// <param name="name">对象池名称。</param>
  410. /// <param name="capacity">对象池的容量。</param>
  411. /// <param name="priority">对象池的优先级。</param>
  412. /// <returns>要创建的允许单次获取的对象池。</returns>
  413. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, int priority) where T : ObjectBase
  414. {
  415. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(name, capacity, priority);
  416. }
  417. /// <summary>
  418. /// 创建允许单次获取的对象池。
  419. /// </summary>
  420. /// <param name="objectType">对象类型。</param>
  421. /// <param name="name">对象池名称。</param>
  422. /// <param name="capacity">对象池的容量。</param>
  423. /// <param name="priority">对象池的优先级。</param>
  424. /// <returns>要创建的允许单次获取的对象池。</returns>
  425. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, int priority)
  426. {
  427. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, name, capacity, priority);
  428. }
  429. /// <summary>
  430. /// 创建允许单次获取的对象池。
  431. /// </summary>
  432. /// <typeparam name="T">对象类型。</typeparam>
  433. /// <param name="name">对象池名称。</param>
  434. /// <param name="expireTime">对象池对象过期秒数。</param>
  435. /// <param name="priority">对象池的优先级。</param>
  436. /// <returns>要创建的允许单次获取的对象池。</returns>
  437. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float expireTime, int priority) where T : ObjectBase
  438. {
  439. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(name, expireTime, priority);
  440. }
  441. /// <summary>
  442. /// 创建允许单次获取的对象池。
  443. /// </summary>
  444. /// <param name="objectType">对象类型。</param>
  445. /// <param name="name">对象池名称。</param>
  446. /// <param name="expireTime">对象池对象过期秒数。</param>
  447. /// <param name="priority">对象池的优先级。</param>
  448. /// <returns>要创建的允许单次获取的对象池。</returns>
  449. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime, int priority)
  450. {
  451. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, name, expireTime, priority);
  452. }
  453. /// <summary>
  454. /// 创建允许单次获取的对象池。
  455. /// </summary>
  456. /// <typeparam name="T">对象类型。</typeparam>
  457. /// <param name="capacity">对象池的容量。</param>
  458. /// <param name="expireTime">对象池对象过期秒数。</param>
  459. /// <param name="priority">对象池的优先级。</param>
  460. /// <returns>要创建的允许单次获取的对象池。</returns>
  461. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, float expireTime, int priority) where T : ObjectBase
  462. {
  463. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(capacity, expireTime, priority);
  464. }
  465. /// <summary>
  466. /// 创建允许单次获取的对象池。
  467. /// </summary>
  468. /// <param name="objectType">对象类型。</param>
  469. /// <param name="capacity">对象池的容量。</param>
  470. /// <param name="expireTime">对象池对象过期秒数。</param>
  471. /// <param name="priority">对象池的优先级。</param>
  472. /// <returns>要创建的允许单次获取的对象池。</returns>
  473. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority)
  474. {
  475. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, capacity, expireTime, priority);
  476. }
  477. /// <summary>
  478. /// 创建允许单次获取的对象池。
  479. /// </summary>
  480. /// <typeparam name="T">对象类型。</typeparam>
  481. /// <param name="name">对象池名称。</param>
  482. /// <param name="capacity">对象池的容量。</param>
  483. /// <param name="expireTime">对象池对象过期秒数。</param>
  484. /// <param name="priority">对象池的优先级。</param>
  485. /// <returns>要创建的允许单次获取的对象池。</returns>
  486. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, float expireTime, int priority) where T : ObjectBase
  487. {
  488. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(name, capacity, expireTime, priority);
  489. }
  490. /// <summary>
  491. /// 创建允许单次获取的对象池。
  492. /// </summary>
  493. /// <param name="objectType">对象类型。</param>
  494. /// <param name="name">对象池名称。</param>
  495. /// <param name="capacity">对象池的容量。</param>
  496. /// <param name="expireTime">对象池对象过期秒数。</param>
  497. /// <param name="priority">对象池的优先级。</param>
  498. /// <returns>要创建的允许单次获取的对象池。</returns>
  499. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime, int priority)
  500. {
  501. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, name, capacity, expireTime, priority);
  502. }
  503. /// <summary>
  504. /// 创建允许单次获取的对象池。
  505. /// </summary>
  506. /// <typeparam name="T">对象类型。</typeparam>
  507. /// <param name="name">对象池名称。</param>
  508. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  509. /// <param name="capacity">对象池的容量。</param>
  510. /// <param name="expireTime">对象池对象过期秒数。</param>
  511. /// <param name="priority">对象池的优先级。</param>
  512. /// <returns>要创建的允许单次获取的对象池。</returns>
  513. public IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase
  514. {
  515. return m_ObjectPoolManager.CreateSingleSpawnObjectPool<T>(name, autoReleaseInterval, capacity, expireTime, priority);
  516. }
  517. /// <summary>
  518. /// 创建允许单次获取的对象池。
  519. /// </summary>
  520. /// <param name="objectType">对象类型。</param>
  521. /// <param name="name">对象池名称。</param>
  522. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  523. /// <param name="capacity">对象池的容量。</param>
  524. /// <param name="expireTime">对象池对象过期秒数。</param>
  525. /// <param name="priority">对象池的优先级。</param>
  526. /// <returns>要创建的允许单次获取的对象池。</returns>
  527. public ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity, float expireTime, int priority)
  528. {
  529. return m_ObjectPoolManager.CreateSingleSpawnObjectPool(objectType, name, autoReleaseInterval, capacity, expireTime, priority);
  530. }
  531. /// <summary>
  532. /// 创建允许多次获取的对象池。
  533. /// </summary>
  534. /// <typeparam name="T">对象类型。</typeparam>
  535. /// <returns>要创建的允许多次获取的对象池。</returns>
  536. public IObjectPool<T> CreateMultiSpawnObjectPool<T>() where T : ObjectBase
  537. {
  538. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>();
  539. }
  540. /// <summary>
  541. /// 创建允许多次获取的对象池。
  542. /// </summary>
  543. /// <param name="objectType">对象类型。</param>
  544. /// <returns>要创建的允许多次获取的对象池。</returns>
  545. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType)
  546. {
  547. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType);
  548. }
  549. /// <summary>
  550. /// 创建允许多次获取的对象池。
  551. /// </summary>
  552. /// <typeparam name="T">对象类型。</typeparam>
  553. /// <param name="name">对象池名称。</param>
  554. /// <returns>要创建的允许多次获取的对象池。</returns>
  555. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name) where T : ObjectBase
  556. {
  557. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(name);
  558. }
  559. /// <summary>
  560. /// 创建允许多次获取的对象池。
  561. /// </summary>
  562. /// <param name="objectType">对象类型。</param>
  563. /// <param name="name">对象池名称。</param>
  564. /// <returns>要创建的允许多次获取的对象池。</returns>
  565. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name)
  566. {
  567. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, name);
  568. }
  569. /// <summary>
  570. /// 创建允许多次获取的对象池。
  571. /// </summary>
  572. /// <typeparam name="T">对象类型。</typeparam>
  573. /// <param name="capacity">对象池的容量。</param>
  574. /// <returns>要创建的允许多次获取的对象池。</returns>
  575. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity) where T : ObjectBase
  576. {
  577. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(capacity);
  578. }
  579. /// <summary>
  580. /// 创建允许多次获取的对象池。
  581. /// </summary>
  582. /// <param name="objectType">对象类型。</param>
  583. /// <param name="capacity">对象池的容量。</param>
  584. /// <returns>要创建的允许多次获取的对象池。</returns>
  585. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity)
  586. {
  587. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, capacity);
  588. }
  589. /// <summary>
  590. /// 创建允许多次获取的对象池。
  591. /// </summary>
  592. /// <typeparam name="T">对象类型。</typeparam>
  593. /// <param name="expireTime">对象池对象过期秒数。</param>
  594. /// <returns>要创建的允许多次获取的对象池。</returns>
  595. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(float expireTime) where T : ObjectBase
  596. {
  597. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(expireTime);
  598. }
  599. /// <summary>
  600. /// 创建允许多次获取的对象池。
  601. /// </summary>
  602. /// <param name="objectType">对象类型。</param>
  603. /// <param name="expireTime">对象池对象过期秒数。</param>
  604. /// <returns>要创建的允许多次获取的对象池。</returns>
  605. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime)
  606. {
  607. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, expireTime);
  608. }
  609. /// <summary>
  610. /// 创建允许多次获取的对象池。
  611. /// </summary>
  612. /// <typeparam name="T">对象类型。</typeparam>
  613. /// <param name="name">对象池名称。</param>
  614. /// <param name="capacity">对象池的容量。</param>
  615. /// <returns>要创建的允许多次获取的对象池。</returns>
  616. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity) where T : ObjectBase
  617. {
  618. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(name, capacity);
  619. }
  620. /// <summary>
  621. /// 创建允许多次获取的对象池。
  622. /// </summary>
  623. /// <param name="objectType">对象类型。</param>
  624. /// <param name="name">对象池名称。</param>
  625. /// <param name="capacity">对象池的容量。</param>
  626. /// <returns>要创建的允许多次获取的对象池。</returns>
  627. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity)
  628. {
  629. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, name, capacity);
  630. }
  631. /// <summary>
  632. /// 创建允许多次获取的对象池。
  633. /// </summary>
  634. /// <typeparam name="T">对象类型。</typeparam>
  635. /// <param name="name">对象池名称。</param>
  636. /// <param name="expireTime">对象池对象过期秒数。</param>
  637. /// <returns>要创建的允许多次获取的对象池。</returns>
  638. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float expireTime) where T : ObjectBase
  639. {
  640. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(name, expireTime);
  641. }
  642. /// <summary>
  643. /// 创建允许多次获取的对象池。
  644. /// </summary>
  645. /// <param name="objectType">对象类型。</param>
  646. /// <param name="name">对象池名称。</param>
  647. /// <param name="expireTime">对象池对象过期秒数。</param>
  648. /// <returns>要创建的允许多次获取的对象池。</returns>
  649. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime)
  650. {
  651. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, name, expireTime);
  652. }
  653. /// <summary>
  654. /// 创建允许多次获取的对象池。
  655. /// </summary>
  656. /// <typeparam name="T">对象类型。</typeparam>
  657. /// <param name="capacity">对象池的容量。</param>
  658. /// <param name="expireTime">对象池对象过期秒数。</param>
  659. /// <returns>要创建的允许多次获取的对象池。</returns>
  660. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, float expireTime) where T : ObjectBase
  661. {
  662. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(capacity, expireTime);
  663. }
  664. /// <summary>
  665. /// 创建允许多次获取的对象池。
  666. /// </summary>
  667. /// <param name="objectType">对象类型。</param>
  668. /// <param name="capacity">对象池的容量。</param>
  669. /// <param name="expireTime">对象池对象过期秒数。</param>
  670. /// <returns>要创建的允许多次获取的对象池。</returns>
  671. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime)
  672. {
  673. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, capacity, expireTime);
  674. }
  675. /// <summary>
  676. /// 创建允许多次获取的对象池。
  677. /// </summary>
  678. /// <typeparam name="T">对象类型。</typeparam>
  679. /// <param name="capacity">对象池的容量。</param>
  680. /// <param name="priority">对象池的优先级。</param>
  681. /// <returns>要创建的允许多次获取的对象池。</returns>
  682. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, int priority) where T : ObjectBase
  683. {
  684. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(capacity, priority);
  685. }
  686. /// <summary>
  687. /// 创建允许多次获取的对象池。
  688. /// </summary>
  689. /// <param name="objectType">对象类型。</param>
  690. /// <param name="capacity">对象池的容量。</param>
  691. /// <param name="priority">对象池的优先级。</param>
  692. /// <returns>要创建的允许多次获取的对象池。</returns>
  693. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, int priority)
  694. {
  695. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, capacity, priority);
  696. }
  697. /// <summary>
  698. /// 创建允许多次获取的对象池。
  699. /// </summary>
  700. /// <typeparam name="T">对象类型。</typeparam>
  701. /// <param name="expireTime">对象池对象过期秒数。</param>
  702. /// <param name="priority">对象池的优先级。</param>
  703. /// <returns>要创建的允许多次获取的对象池。</returns>
  704. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(float expireTime, int priority) where T : ObjectBase
  705. {
  706. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(expireTime, priority);
  707. }
  708. /// <summary>
  709. /// 创建允许多次获取的对象池。
  710. /// </summary>
  711. /// <param name="objectType">对象类型。</param>
  712. /// <param name="expireTime">对象池对象过期秒数。</param>
  713. /// <param name="priority">对象池的优先级。</param>
  714. /// <returns>要创建的允许多次获取的对象池。</returns>
  715. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime, int priority)
  716. {
  717. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, expireTime, priority);
  718. }
  719. /// <summary>
  720. /// 创建允许多次获取的对象池。
  721. /// </summary>
  722. /// <typeparam name="T">对象类型。</typeparam>
  723. /// <param name="name">对象池名称。</param>
  724. /// <param name="capacity">对象池的容量。</param>
  725. /// <param name="expireTime">对象池对象过期秒数。</param>
  726. /// <returns>要创建的允许多次获取的对象池。</returns>
  727. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, float expireTime) where T : ObjectBase
  728. {
  729. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(name, capacity, expireTime);
  730. }
  731. /// <summary>
  732. /// 创建允许多次获取的对象池。
  733. /// </summary>
  734. /// <param name="objectType">对象类型。</param>
  735. /// <param name="name">对象池名称。</param>
  736. /// <param name="capacity">对象池的容量。</param>
  737. /// <param name="expireTime">对象池对象过期秒数。</param>
  738. /// <returns>要创建的允许多次获取的对象池。</returns>
  739. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime)
  740. {
  741. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, name, capacity, expireTime);
  742. }
  743. /// <summary>
  744. /// 创建允许多次获取的对象池。
  745. /// </summary>
  746. /// <typeparam name="T">对象类型。</typeparam>
  747. /// <param name="name">对象池名称。</param>
  748. /// <param name="capacity">对象池的容量。</param>
  749. /// <param name="priority">对象池的优先级。</param>
  750. /// <returns>要创建的允许多次获取的对象池。</returns>
  751. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, int priority) where T : ObjectBase
  752. {
  753. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(name, capacity, priority);
  754. }
  755. /// <summary>
  756. /// 创建允许多次获取的对象池。
  757. /// </summary>
  758. /// <param name="objectType">对象类型。</param>
  759. /// <param name="name">对象池名称。</param>
  760. /// <param name="capacity">对象池的容量。</param>
  761. /// <param name="priority">对象池的优先级。</param>
  762. /// <returns>要创建的允许多次获取的对象池。</returns>
  763. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, int priority)
  764. {
  765. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, name, capacity, priority);
  766. }
  767. /// <summary>
  768. /// 创建允许多次获取的对象池。
  769. /// </summary>
  770. /// <typeparam name="T">对象类型。</typeparam>
  771. /// <param name="name">对象池名称。</param>
  772. /// <param name="expireTime">对象池对象过期秒数。</param>
  773. /// <param name="priority">对象池的优先级。</param>
  774. /// <returns>要创建的允许多次获取的对象池。</returns>
  775. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float expireTime, int priority) where T : ObjectBase
  776. {
  777. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(name, expireTime, priority);
  778. }
  779. /// <summary>
  780. /// 创建允许多次获取的对象池。
  781. /// </summary>
  782. /// <param name="objectType">对象类型。</param>
  783. /// <param name="name">对象池名称。</param>
  784. /// <param name="expireTime">对象池对象过期秒数。</param>
  785. /// <param name="priority">对象池的优先级。</param>
  786. /// <returns>要创建的允许多次获取的对象池。</returns>
  787. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime, int priority)
  788. {
  789. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, name, expireTime, priority);
  790. }
  791. /// <summary>
  792. /// 创建允许多次获取的对象池。
  793. /// </summary>
  794. /// <typeparam name="T">对象类型。</typeparam>
  795. /// <param name="capacity">对象池的容量。</param>
  796. /// <param name="expireTime">对象池对象过期秒数。</param>
  797. /// <param name="priority">对象池的优先级。</param>
  798. /// <returns>要创建的允许多次获取的对象池。</returns>
  799. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, float expireTime, int priority) where T : ObjectBase
  800. {
  801. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(capacity, expireTime, priority);
  802. }
  803. /// <summary>
  804. /// 创建允许多次获取的对象池。
  805. /// </summary>
  806. /// <param name="objectType">对象类型。</param>
  807. /// <param name="capacity">对象池的容量。</param>
  808. /// <param name="expireTime">对象池对象过期秒数。</param>
  809. /// <param name="priority">对象池的优先级。</param>
  810. /// <returns>要创建的允许多次获取的对象池。</returns>
  811. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority)
  812. {
  813. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, capacity, expireTime, priority);
  814. }
  815. /// <summary>
  816. /// 创建允许多次获取的对象池。
  817. /// </summary>
  818. /// <typeparam name="T">对象类型。</typeparam>
  819. /// <param name="name">对象池名称。</param>
  820. /// <param name="capacity">对象池的容量。</param>
  821. /// <param name="expireTime">对象池对象过期秒数。</param>
  822. /// <param name="priority">对象池的优先级。</param>
  823. /// <returns>要创建的允许多次获取的对象池。</returns>
  824. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, float expireTime, int priority) where T : ObjectBase
  825. {
  826. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(name, capacity, expireTime, priority);
  827. }
  828. /// <summary>
  829. /// 创建允许多次获取的对象池。
  830. /// </summary>
  831. /// <param name="objectType">对象类型。</param>
  832. /// <param name="name">对象池名称。</param>
  833. /// <param name="capacity">对象池的容量。</param>
  834. /// <param name="expireTime">对象池对象过期秒数。</param>
  835. /// <param name="priority">对象池的优先级。</param>
  836. /// <returns>要创建的允许多次获取的对象池。</returns>
  837. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime, int priority)
  838. {
  839. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, name, capacity, expireTime, priority);
  840. }
  841. /// <summary>
  842. /// 创建允许多次获取的对象池。
  843. /// </summary>
  844. /// <typeparam name="T">对象类型。</typeparam>
  845. /// <param name="name">对象池名称。</param>
  846. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  847. /// <param name="capacity">对象池的容量。</param>
  848. /// <param name="expireTime">对象池对象过期秒数。</param>
  849. /// <param name="priority">对象池的优先级。</param>
  850. /// <returns>要创建的允许多次获取的对象池。</returns>
  851. public IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase
  852. {
  853. return m_ObjectPoolManager.CreateMultiSpawnObjectPool<T>(name, autoReleaseInterval, capacity, expireTime, priority);
  854. }
  855. /// <summary>
  856. /// 创建允许多次获取的对象池。
  857. /// </summary>
  858. /// <param name="objectType">对象类型。</param>
  859. /// <param name="name">对象池名称。</param>
  860. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  861. /// <param name="capacity">对象池的容量。</param>
  862. /// <param name="expireTime">对象池对象过期秒数。</param>
  863. /// <param name="priority">对象池的优先级。</param>
  864. /// <returns>要创建的允许多次获取的对象池。</returns>
  865. public ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity, float expireTime, int priority)
  866. {
  867. return m_ObjectPoolManager.CreateMultiSpawnObjectPool(objectType, name, autoReleaseInterval, capacity, expireTime, priority);
  868. }
  869. /// <summary>
  870. /// 销毁对象池。
  871. /// </summary>
  872. /// <typeparam name="T">对象类型。</typeparam>
  873. /// <returns>是否销毁对象池成功。</returns>
  874. public bool DestroyObjectPool<T>() where T : ObjectBase
  875. {
  876. return m_ObjectPoolManager.DestroyObjectPool<T>();
  877. }
  878. /// <summary>
  879. /// 销毁对象池。
  880. /// </summary>
  881. /// <param name="objectType">对象类型。</param>
  882. /// <returns>是否销毁对象池成功。</returns>
  883. public bool DestroyObjectPool(Type objectType)
  884. {
  885. return m_ObjectPoolManager.DestroyObjectPool(objectType);
  886. }
  887. /// <summary>
  888. /// 销毁对象池。
  889. /// </summary>
  890. /// <typeparam name="T">对象类型。</typeparam>
  891. /// <param name="name">要销毁的对象池名称。</param>
  892. /// <returns>是否销毁对象池成功。</returns>
  893. public bool DestroyObjectPool<T>(string name) where T : ObjectBase
  894. {
  895. return m_ObjectPoolManager.DestroyObjectPool<T>(name);
  896. }
  897. /// <summary>
  898. /// 销毁对象池。
  899. /// </summary>
  900. /// <param name="objectType">对象类型。</param>
  901. /// <param name="name">要销毁的对象池名称。</param>
  902. /// <returns>是否销毁对象池成功。</returns>
  903. public bool DestroyObjectPool(Type objectType, string name)
  904. {
  905. return m_ObjectPoolManager.DestroyObjectPool(objectType, name);
  906. }
  907. /// <summary>
  908. /// 销毁对象池。
  909. /// </summary>
  910. /// <typeparam name="T">对象类型。</typeparam>
  911. /// <param name="objectPool">要销毁的对象池。</param>
  912. /// <returns>是否销毁对象池成功。</returns>
  913. public bool DestroyObjectPool<T>(IObjectPool<T> objectPool) where T : ObjectBase
  914. {
  915. return m_ObjectPoolManager.DestroyObjectPool(objectPool);
  916. }
  917. /// <summary>
  918. /// 销毁对象池。
  919. /// </summary>
  920. /// <param name="objectPool">要销毁的对象池。</param>
  921. /// <returns>是否销毁对象池成功。</returns>
  922. public bool DestroyObjectPool(ObjectPoolBase objectPool)
  923. {
  924. return m_ObjectPoolManager.DestroyObjectPool(objectPool);
  925. }
  926. /// <summary>
  927. /// 释放对象池中的可释放对象。
  928. /// </summary>
  929. public void Release()
  930. {
  931. Log.Info("Object pool release...");
  932. m_ObjectPoolManager.Release();
  933. }
  934. /// <summary>
  935. /// 释放对象池中的所有未使用对象。
  936. /// </summary>
  937. public void ReleaseAllUnused()
  938. {
  939. Log.Info("Object pool release all unused...");
  940. m_ObjectPoolManager.ReleaseAllUnused();
  941. }
  942. }
  943. }