IObjectPoolManager.cs 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751
  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 System;
  8. using System.Collections.Generic;
  9. namespace GameFramework.ObjectPool
  10. {
  11. /// <summary>
  12. /// 对象池管理器。
  13. /// </summary>
  14. public interface IObjectPoolManager
  15. {
  16. /// <summary>
  17. /// 获取对象池数量。
  18. /// </summary>
  19. int Count
  20. {
  21. get;
  22. }
  23. /// <summary>
  24. /// 检查是否存在对象池。
  25. /// </summary>
  26. /// <typeparam name="T">对象类型。</typeparam>
  27. /// <returns>是否存在对象池。</returns>
  28. bool HasObjectPool<T>() where T : ObjectBase;
  29. /// <summary>
  30. /// 检查是否存在对象池。
  31. /// </summary>
  32. /// <param name="objectType">对象类型。</param>
  33. /// <returns>是否存在对象池。</returns>
  34. bool HasObjectPool(Type objectType);
  35. /// <summary>
  36. /// 检查是否存在对象池。
  37. /// </summary>
  38. /// <typeparam name="T">对象类型。</typeparam>
  39. /// <param name="name">对象池名称。</param>
  40. /// <returns>是否存在对象池。</returns>
  41. bool HasObjectPool<T>(string name) where T : ObjectBase;
  42. /// <summary>
  43. /// 检查是否存在对象池。
  44. /// </summary>
  45. /// <param name="objectType">对象类型。</param>
  46. /// <param name="name">对象池名称。</param>
  47. /// <returns>是否存在对象池。</returns>
  48. bool HasObjectPool(Type objectType, string name);
  49. /// <summary>
  50. /// 检查是否存在对象池。
  51. /// </summary>
  52. /// <param name="condition">要检查的条件。</param>
  53. /// <returns>是否存在对象池。</returns>
  54. bool HasObjectPool(Predicate<ObjectPoolBase> condition);
  55. /// <summary>
  56. /// 获取对象池。
  57. /// </summary>
  58. /// <typeparam name="T">对象类型。</typeparam>
  59. /// <returns>要获取的对象池。</returns>
  60. IObjectPool<T> GetObjectPool<T>() where T : ObjectBase;
  61. /// <summary>
  62. /// 获取对象池。
  63. /// </summary>
  64. /// <param name="objectType">对象类型。</param>
  65. /// <returns>要获取的对象池。</returns>
  66. ObjectPoolBase GetObjectPool(Type objectType);
  67. /// <summary>
  68. /// 获取对象池。
  69. /// </summary>
  70. /// <typeparam name="T">对象类型。</typeparam>
  71. /// <param name="name">对象池名称。</param>
  72. /// <returns>要获取的对象池。</returns>
  73. IObjectPool<T> GetObjectPool<T>(string name) where T : ObjectBase;
  74. /// <summary>
  75. /// 获取对象池。
  76. /// </summary>
  77. /// <param name="objectType">对象类型。</param>
  78. /// <param name="name">对象池名称。</param>
  79. /// <returns>要获取的对象池。</returns>
  80. ObjectPoolBase GetObjectPool(Type objectType, string name);
  81. /// <summary>
  82. /// 获取对象池。
  83. /// </summary>
  84. /// <param name="condition">要检查的条件。</param>
  85. /// <returns>要获取的对象池。</returns>
  86. ObjectPoolBase GetObjectPool(Predicate<ObjectPoolBase> condition);
  87. /// <summary>
  88. /// 获取对象池。
  89. /// </summary>
  90. /// <param name="condition">要检查的条件。</param>
  91. /// <returns>要获取的对象池。</returns>
  92. ObjectPoolBase[] GetObjectPools(Predicate<ObjectPoolBase> condition);
  93. /// <summary>
  94. /// 获取对象池。
  95. /// </summary>
  96. /// <param name="condition">要检查的条件。</param>
  97. /// <param name="results">要获取的对象池。</param>
  98. void GetObjectPools(Predicate<ObjectPoolBase> condition, List<ObjectPoolBase> results);
  99. /// <summary>
  100. /// 获取所有对象池。
  101. /// </summary>
  102. /// <returns>所有对象池。</returns>
  103. ObjectPoolBase[] GetAllObjectPools();
  104. /// <summary>
  105. /// 获取所有对象池。
  106. /// </summary>
  107. /// <param name="results">所有对象池。</param>
  108. void GetAllObjectPools(List<ObjectPoolBase> results);
  109. /// <summary>
  110. /// 获取所有对象池。
  111. /// </summary>
  112. /// <param name="sort">是否根据对象池的优先级排序。</param>
  113. /// <returns>所有对象池。</returns>
  114. ObjectPoolBase[] GetAllObjectPools(bool sort);
  115. /// <summary>
  116. /// 获取所有对象池。
  117. /// </summary>
  118. /// <param name="sort">是否根据对象池的优先级排序。</param>
  119. /// <param name="results">所有对象池。</param>
  120. void GetAllObjectPools(bool sort, List<ObjectPoolBase> results);
  121. /// <summary>
  122. /// 创建允许单次获取的对象池。
  123. /// </summary>
  124. /// <typeparam name="T">对象类型。</typeparam>
  125. /// <returns>要创建的允许单次获取的对象池。</returns>
  126. IObjectPool<T> CreateSingleSpawnObjectPool<T>() where T : ObjectBase;
  127. /// <summary>
  128. /// 创建允许单次获取的对象池。
  129. /// </summary>
  130. /// <param name="objectType">对象类型。</param>
  131. /// <returns>要创建的允许单次获取的对象池。</returns>
  132. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType);
  133. /// <summary>
  134. /// 创建允许单次获取的对象池。
  135. /// </summary>
  136. /// <typeparam name="T">对象类型。</typeparam>
  137. /// <param name="name">对象池名称。</param>
  138. /// <returns>要创建的允许单次获取的对象池。</returns>
  139. IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name) where T : ObjectBase;
  140. /// <summary>
  141. /// 创建允许单次获取的对象池。
  142. /// </summary>
  143. /// <param name="objectType">对象类型。</param>
  144. /// <param name="name">对象池名称。</param>
  145. /// <returns>要创建的允许单次获取的对象池。</returns>
  146. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name);
  147. /// <summary>
  148. /// 创建允许单次获取的对象池。
  149. /// </summary>
  150. /// <typeparam name="T">对象类型。</typeparam>
  151. /// <param name="capacity">对象池的容量。</param>
  152. /// <returns>要创建的允许单次获取的对象池。</returns>
  153. IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity) where T : ObjectBase;
  154. /// <summary>
  155. /// 创建允许单次获取的对象池。
  156. /// </summary>
  157. /// <param name="objectType">对象类型。</param>
  158. /// <param name="capacity">对象池的容量。</param>
  159. /// <returns>要创建的允许单次获取的对象池。</returns>
  160. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity);
  161. /// <summary>
  162. /// 创建允许单次获取的对象池。
  163. /// </summary>
  164. /// <typeparam name="T">对象类型。</typeparam>
  165. /// <param name="expireTime">对象池对象过期秒数。</param>
  166. /// <returns>要创建的允许单次获取的对象池。</returns>
  167. IObjectPool<T> CreateSingleSpawnObjectPool<T>(float expireTime) where T : ObjectBase;
  168. /// <summary>
  169. /// 创建允许单次获取的对象池。
  170. /// </summary>
  171. /// <param name="objectType">对象类型。</param>
  172. /// <param name="expireTime">对象池对象过期秒数。</param>
  173. /// <returns>要创建的允许单次获取的对象池。</returns>
  174. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime);
  175. /// <summary>
  176. /// 创建允许单次获取的对象池。
  177. /// </summary>
  178. /// <typeparam name="T">对象类型。</typeparam>
  179. /// <param name="name">对象池名称。</param>
  180. /// <param name="capacity">对象池的容量。</param>
  181. /// <returns>要创建的允许单次获取的对象池。</returns>
  182. IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity) where T : ObjectBase;
  183. /// <summary>
  184. /// 创建允许单次获取的对象池。
  185. /// </summary>
  186. /// <param name="objectType">对象类型。</param>
  187. /// <param name="name">对象池名称。</param>
  188. /// <param name="capacity">对象池的容量。</param>
  189. /// <returns>要创建的允许单次获取的对象池。</returns>
  190. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity);
  191. /// <summary>
  192. /// 创建允许单次获取的对象池。
  193. /// </summary>
  194. /// <typeparam name="T">对象类型。</typeparam>
  195. /// <param name="name">对象池名称。</param>
  196. /// <param name="expireTime">对象池对象过期秒数。</param>
  197. /// <returns>要创建的允许单次获取的对象池。</returns>
  198. IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float expireTime) where T : ObjectBase;
  199. /// <summary>
  200. /// 创建允许单次获取的对象池。
  201. /// </summary>
  202. /// <param name="objectType">对象类型。</param>
  203. /// <param name="name">对象池名称。</param>
  204. /// <param name="expireTime">对象池对象过期秒数。</param>
  205. /// <returns>要创建的允许单次获取的对象池。</returns>
  206. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime);
  207. /// <summary>
  208. /// 创建允许单次获取的对象池。
  209. /// </summary>
  210. /// <typeparam name="T">对象类型。</typeparam>
  211. /// <param name="capacity">对象池的容量。</param>
  212. /// <param name="expireTime">对象池对象过期秒数。</param>
  213. /// <returns>要创建的允许单次获取的对象池。</returns>
  214. IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, float expireTime) where T : ObjectBase;
  215. /// <summary>
  216. /// 创建允许单次获取的对象池。
  217. /// </summary>
  218. /// <param name="objectType">对象类型。</param>
  219. /// <param name="capacity">对象池的容量。</param>
  220. /// <param name="expireTime">对象池对象过期秒数。</param>
  221. /// <returns>要创建的允许单次获取的对象池。</returns>
  222. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime);
  223. /// <summary>
  224. /// 创建允许单次获取的对象池。
  225. /// </summary>
  226. /// <typeparam name="T">对象类型。</typeparam>
  227. /// <param name="capacity">对象池的容量。</param>
  228. /// <param name="priority">对象池的优先级。</param>
  229. /// <returns>要创建的允许单次获取的对象池。</returns>
  230. IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, int priority) where T : ObjectBase;
  231. /// <summary>
  232. /// 创建允许单次获取的对象池。
  233. /// </summary>
  234. /// <param name="objectType">对象类型。</param>
  235. /// <param name="capacity">对象池的容量。</param>
  236. /// <param name="priority">对象池的优先级。</param>
  237. /// <returns>要创建的允许单次获取的对象池。</returns>
  238. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, int priority);
  239. /// <summary>
  240. /// 创建允许单次获取的对象池。
  241. /// </summary>
  242. /// <typeparam name="T">对象类型。</typeparam>
  243. /// <param name="expireTime">对象池对象过期秒数。</param>
  244. /// <param name="priority">对象池的优先级。</param>
  245. /// <returns>要创建的允许单次获取的对象池。</returns>
  246. IObjectPool<T> CreateSingleSpawnObjectPool<T>(float expireTime, int priority) where T : ObjectBase;
  247. /// <summary>
  248. /// 创建允许单次获取的对象池。
  249. /// </summary>
  250. /// <param name="objectType">对象类型。</param>
  251. /// <param name="expireTime">对象池对象过期秒数。</param>
  252. /// <param name="priority">对象池的优先级。</param>
  253. /// <returns>要创建的允许单次获取的对象池。</returns>
  254. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime, int priority);
  255. /// <summary>
  256. /// 创建允许单次获取的对象池。
  257. /// </summary>
  258. /// <typeparam name="T">对象类型。</typeparam>
  259. /// <param name="name">对象池名称。</param>
  260. /// <param name="capacity">对象池的容量。</param>
  261. /// <param name="expireTime">对象池对象过期秒数。</param>
  262. /// <returns>要创建的允许单次获取的对象池。</returns>
  263. IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, float expireTime) where T : ObjectBase;
  264. /// <summary>
  265. /// 创建允许单次获取的对象池。
  266. /// </summary>
  267. /// <param name="objectType">对象类型。</param>
  268. /// <param name="name">对象池名称。</param>
  269. /// <param name="capacity">对象池的容量。</param>
  270. /// <param name="expireTime">对象池对象过期秒数。</param>
  271. /// <returns>要创建的允许单次获取的对象池。</returns>
  272. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime);
  273. /// <summary>
  274. /// 创建允许单次获取的对象池。
  275. /// </summary>
  276. /// <typeparam name="T">对象类型。</typeparam>
  277. /// <param name="name">对象池名称。</param>
  278. /// <param name="capacity">对象池的容量。</param>
  279. /// <param name="priority">对象池的优先级。</param>
  280. /// <returns>要创建的允许单次获取的对象池。</returns>
  281. IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, int priority) where T : ObjectBase;
  282. /// <summary>
  283. /// 创建允许单次获取的对象池。
  284. /// </summary>
  285. /// <param name="objectType">对象类型。</param>
  286. /// <param name="name">对象池名称。</param>
  287. /// <param name="capacity">对象池的容量。</param>
  288. /// <param name="priority">对象池的优先级。</param>
  289. /// <returns>要创建的允许单次获取的对象池。</returns>
  290. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, int priority);
  291. /// <summary>
  292. /// 创建允许单次获取的对象池。
  293. /// </summary>
  294. /// <typeparam name="T">对象类型。</typeparam>
  295. /// <param name="name">对象池名称。</param>
  296. /// <param name="expireTime">对象池对象过期秒数。</param>
  297. /// <param name="priority">对象池的优先级。</param>
  298. /// <returns>要创建的允许单次获取的对象池。</returns>
  299. IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float expireTime, int priority) where T : ObjectBase;
  300. /// <summary>
  301. /// 创建允许单次获取的对象池。
  302. /// </summary>
  303. /// <param name="objectType">对象类型。</param>
  304. /// <param name="name">对象池名称。</param>
  305. /// <param name="expireTime">对象池对象过期秒数。</param>
  306. /// <param name="priority">对象池的优先级。</param>
  307. /// <returns>要创建的允许单次获取的对象池。</returns>
  308. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime, int priority);
  309. /// <summary>
  310. /// 创建允许单次获取的对象池。
  311. /// </summary>
  312. /// <typeparam name="T">对象类型。</typeparam>
  313. /// <param name="capacity">对象池的容量。</param>
  314. /// <param name="expireTime">对象池对象过期秒数。</param>
  315. /// <param name="priority">对象池的优先级。</param>
  316. /// <returns>要创建的允许单次获取的对象池。</returns>
  317. IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, float expireTime, int priority) where T : ObjectBase;
  318. /// <summary>
  319. /// 创建允许单次获取的对象池。
  320. /// </summary>
  321. /// <param name="objectType">对象类型。</param>
  322. /// <param name="capacity">对象池的容量。</param>
  323. /// <param name="expireTime">对象池对象过期秒数。</param>
  324. /// <param name="priority">对象池的优先级。</param>
  325. /// <returns>要创建的允许单次获取的对象池。</returns>
  326. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority);
  327. /// <summary>
  328. /// 创建允许单次获取的对象池。
  329. /// </summary>
  330. /// <typeparam name="T">对象类型。</typeparam>
  331. /// <param name="name">对象池名称。</param>
  332. /// <param name="capacity">对象池的容量。</param>
  333. /// <param name="expireTime">对象池对象过期秒数。</param>
  334. /// <param name="priority">对象池的优先级。</param>
  335. /// <returns>要创建的允许单次获取的对象池。</returns>
  336. IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, float expireTime, int priority) where T : ObjectBase;
  337. /// <summary>
  338. /// 创建允许单次获取的对象池。
  339. /// </summary>
  340. /// <param name="objectType">对象类型。</param>
  341. /// <param name="name">对象池名称。</param>
  342. /// <param name="capacity">对象池的容量。</param>
  343. /// <param name="expireTime">对象池对象过期秒数。</param>
  344. /// <param name="priority">对象池的优先级。</param>
  345. /// <returns>要创建的允许单次获取的对象池。</returns>
  346. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime, int priority);
  347. /// <summary>
  348. /// 创建允许单次获取的对象池。
  349. /// </summary>
  350. /// <typeparam name="T">对象类型。</typeparam>
  351. /// <param name="name">对象池名称。</param>
  352. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  353. /// <param name="capacity">对象池的容量。</param>
  354. /// <param name="expireTime">对象池对象过期秒数。</param>
  355. /// <param name="priority">对象池的优先级。</param>
  356. /// <returns>要创建的允许单次获取的对象池。</returns>
  357. IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase;
  358. /// <summary>
  359. /// 创建允许单次获取的对象池。
  360. /// </summary>
  361. /// <param name="objectType">对象类型。</param>
  362. /// <param name="name">对象池名称。</param>
  363. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  364. /// <param name="capacity">对象池的容量。</param>
  365. /// <param name="expireTime">对象池对象过期秒数。</param>
  366. /// <param name="priority">对象池的优先级。</param>
  367. /// <returns>要创建的允许单次获取的对象池。</returns>
  368. ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity, float expireTime, int priority);
  369. /// <summary>
  370. /// 创建允许多次获取的对象池。
  371. /// </summary>
  372. /// <typeparam name="T">对象类型。</typeparam>
  373. /// <returns>要创建的允许多次获取的对象池。</returns>
  374. IObjectPool<T> CreateMultiSpawnObjectPool<T>() where T : ObjectBase;
  375. /// <summary>
  376. /// 创建允许多次获取的对象池。
  377. /// </summary>
  378. /// <param name="objectType">对象类型。</param>
  379. /// <returns>要创建的允许多次获取的对象池。</returns>
  380. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType);
  381. /// <summary>
  382. /// 创建允许多次获取的对象池。
  383. /// </summary>
  384. /// <typeparam name="T">对象类型。</typeparam>
  385. /// <param name="name">对象池名称。</param>
  386. /// <returns>要创建的允许多次获取的对象池。</returns>
  387. IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name) where T : ObjectBase;
  388. /// <summary>
  389. /// 创建允许多次获取的对象池。
  390. /// </summary>
  391. /// <param name="objectType">对象类型。</param>
  392. /// <param name="name">对象池名称。</param>
  393. /// <returns>要创建的允许多次获取的对象池。</returns>
  394. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name);
  395. /// <summary>
  396. /// 创建允许多次获取的对象池。
  397. /// </summary>
  398. /// <typeparam name="T">对象类型。</typeparam>
  399. /// <param name="capacity">对象池的容量。</param>
  400. /// <returns>要创建的允许多次获取的对象池。</returns>
  401. IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity) where T : ObjectBase;
  402. /// <summary>
  403. /// 创建允许多次获取的对象池。
  404. /// </summary>
  405. /// <param name="objectType">对象类型。</param>
  406. /// <param name="capacity">对象池的容量。</param>
  407. /// <returns>要创建的允许多次获取的对象池。</returns>
  408. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity);
  409. /// <summary>
  410. /// 创建允许多次获取的对象池。
  411. /// </summary>
  412. /// <typeparam name="T">对象类型。</typeparam>
  413. /// <param name="expireTime">对象池对象过期秒数。</param>
  414. /// <returns>要创建的允许多次获取的对象池。</returns>
  415. IObjectPool<T> CreateMultiSpawnObjectPool<T>(float expireTime) where T : ObjectBase;
  416. /// <summary>
  417. /// 创建允许多次获取的对象池。
  418. /// </summary>
  419. /// <param name="objectType">对象类型。</param>
  420. /// <param name="expireTime">对象池对象过期秒数。</param>
  421. /// <returns>要创建的允许多次获取的对象池。</returns>
  422. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime);
  423. /// <summary>
  424. /// 创建允许多次获取的对象池。
  425. /// </summary>
  426. /// <typeparam name="T">对象类型。</typeparam>
  427. /// <param name="name">对象池名称。</param>
  428. /// <param name="capacity">对象池的容量。</param>
  429. /// <returns>要创建的允许多次获取的对象池。</returns>
  430. IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity) where T : ObjectBase;
  431. /// <summary>
  432. /// 创建允许多次获取的对象池。
  433. /// </summary>
  434. /// <param name="objectType">对象类型。</param>
  435. /// <param name="name">对象池名称。</param>
  436. /// <param name="capacity">对象池的容量。</param>
  437. /// <returns>要创建的允许多次获取的对象池。</returns>
  438. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity);
  439. /// <summary>
  440. /// 创建允许多次获取的对象池。
  441. /// </summary>
  442. /// <typeparam name="T">对象类型。</typeparam>
  443. /// <param name="name">对象池名称。</param>
  444. /// <param name="expireTime">对象池对象过期秒数。</param>
  445. /// <returns>要创建的允许多次获取的对象池。</returns>
  446. IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float expireTime) where T : ObjectBase;
  447. /// <summary>
  448. /// 创建允许多次获取的对象池。
  449. /// </summary>
  450. /// <param name="objectType">对象类型。</param>
  451. /// <param name="name">对象池名称。</param>
  452. /// <param name="expireTime">对象池对象过期秒数。</param>
  453. /// <returns>要创建的允许多次获取的对象池。</returns>
  454. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime);
  455. /// <summary>
  456. /// 创建允许多次获取的对象池。
  457. /// </summary>
  458. /// <typeparam name="T">对象类型。</typeparam>
  459. /// <param name="capacity">对象池的容量。</param>
  460. /// <param name="expireTime">对象池对象过期秒数。</param>
  461. /// <returns>要创建的允许多次获取的对象池。</returns>
  462. IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, float expireTime) where T : ObjectBase;
  463. /// <summary>
  464. /// 创建允许多次获取的对象池。
  465. /// </summary>
  466. /// <param name="objectType">对象类型。</param>
  467. /// <param name="capacity">对象池的容量。</param>
  468. /// <param name="expireTime">对象池对象过期秒数。</param>
  469. /// <returns>要创建的允许多次获取的对象池。</returns>
  470. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime);
  471. /// <summary>
  472. /// 创建允许多次获取的对象池。
  473. /// </summary>
  474. /// <typeparam name="T">对象类型。</typeparam>
  475. /// <param name="capacity">对象池的容量。</param>
  476. /// <param name="priority">对象池的优先级。</param>
  477. /// <returns>要创建的允许多次获取的对象池。</returns>
  478. IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, int priority) where T : ObjectBase;
  479. /// <summary>
  480. /// 创建允许多次获取的对象池。
  481. /// </summary>
  482. /// <param name="objectType">对象类型。</param>
  483. /// <param name="capacity">对象池的容量。</param>
  484. /// <param name="priority">对象池的优先级。</param>
  485. /// <returns>要创建的允许多次获取的对象池。</returns>
  486. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, int priority);
  487. /// <summary>
  488. /// 创建允许多次获取的对象池。
  489. /// </summary>
  490. /// <typeparam name="T">对象类型。</typeparam>
  491. /// <param name="expireTime">对象池对象过期秒数。</param>
  492. /// <param name="priority">对象池的优先级。</param>
  493. /// <returns>要创建的允许多次获取的对象池。</returns>
  494. IObjectPool<T> CreateMultiSpawnObjectPool<T>(float expireTime, int priority) where T : ObjectBase;
  495. /// <summary>
  496. /// 创建允许多次获取的对象池。
  497. /// </summary>
  498. /// <param name="objectType">对象类型。</param>
  499. /// <param name="expireTime">对象池对象过期秒数。</param>
  500. /// <param name="priority">对象池的优先级。</param>
  501. /// <returns>要创建的允许多次获取的对象池。</returns>
  502. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime, int priority);
  503. /// <summary>
  504. /// 创建允许多次获取的对象池。
  505. /// </summary>
  506. /// <typeparam name="T">对象类型。</typeparam>
  507. /// <param name="name">对象池名称。</param>
  508. /// <param name="capacity">对象池的容量。</param>
  509. /// <param name="expireTime">对象池对象过期秒数。</param>
  510. /// <returns>要创建的允许多次获取的对象池。</returns>
  511. IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, float expireTime) where T : ObjectBase;
  512. /// <summary>
  513. /// 创建允许多次获取的对象池。
  514. /// </summary>
  515. /// <param name="objectType">对象类型。</param>
  516. /// <param name="name">对象池名称。</param>
  517. /// <param name="capacity">对象池的容量。</param>
  518. /// <param name="expireTime">对象池对象过期秒数。</param>
  519. /// <returns>要创建的允许多次获取的对象池。</returns>
  520. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime);
  521. /// <summary>
  522. /// 创建允许多次获取的对象池。
  523. /// </summary>
  524. /// <typeparam name="T">对象类型。</typeparam>
  525. /// <param name="name">对象池名称。</param>
  526. /// <param name="capacity">对象池的容量。</param>
  527. /// <param name="priority">对象池的优先级。</param>
  528. /// <returns>要创建的允许多次获取的对象池。</returns>
  529. IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, int priority) where T : ObjectBase;
  530. /// <summary>
  531. /// 创建允许多次获取的对象池。
  532. /// </summary>
  533. /// <param name="objectType">对象类型。</param>
  534. /// <param name="name">对象池名称。</param>
  535. /// <param name="capacity">对象池的容量。</param>
  536. /// <param name="priority">对象池的优先级。</param>
  537. /// <returns>要创建的允许多次获取的对象池。</returns>
  538. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, int priority);
  539. /// <summary>
  540. /// 创建允许多次获取的对象池。
  541. /// </summary>
  542. /// <typeparam name="T">对象类型。</typeparam>
  543. /// <param name="name">对象池名称。</param>
  544. /// <param name="expireTime">对象池对象过期秒数。</param>
  545. /// <param name="priority">对象池的优先级。</param>
  546. /// <returns>要创建的允许多次获取的对象池。</returns>
  547. IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float expireTime, int priority) where T : ObjectBase;
  548. /// <summary>
  549. /// 创建允许多次获取的对象池。
  550. /// </summary>
  551. /// <param name="objectType">对象类型。</param>
  552. /// <param name="name">对象池名称。</param>
  553. /// <param name="expireTime">对象池对象过期秒数。</param>
  554. /// <param name="priority">对象池的优先级。</param>
  555. /// <returns>要创建的允许多次获取的对象池。</returns>
  556. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime, int priority);
  557. /// <summary>
  558. /// 创建允许多次获取的对象池。
  559. /// </summary>
  560. /// <typeparam name="T">对象类型。</typeparam>
  561. /// <param name="capacity">对象池的容量。</param>
  562. /// <param name="expireTime">对象池对象过期秒数。</param>
  563. /// <param name="priority">对象池的优先级。</param>
  564. /// <returns>要创建的允许多次获取的对象池。</returns>
  565. IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, float expireTime, int priority) where T : ObjectBase;
  566. /// <summary>
  567. /// 创建允许多次获取的对象池。
  568. /// </summary>
  569. /// <param name="objectType">对象类型。</param>
  570. /// <param name="capacity">对象池的容量。</param>
  571. /// <param name="expireTime">对象池对象过期秒数。</param>
  572. /// <param name="priority">对象池的优先级。</param>
  573. /// <returns>要创建的允许多次获取的对象池。</returns>
  574. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority);
  575. /// <summary>
  576. /// 创建允许多次获取的对象池。
  577. /// </summary>
  578. /// <typeparam name="T">对象类型。</typeparam>
  579. /// <param name="name">对象池名称。</param>
  580. /// <param name="capacity">对象池的容量。</param>
  581. /// <param name="expireTime">对象池对象过期秒数。</param>
  582. /// <param name="priority">对象池的优先级。</param>
  583. /// <returns>要创建的允许多次获取的对象池。</returns>
  584. IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, float expireTime, int priority) where T : ObjectBase;
  585. /// <summary>
  586. /// 创建允许多次获取的对象池。
  587. /// </summary>
  588. /// <param name="objectType">对象类型。</param>
  589. /// <param name="name">对象池名称。</param>
  590. /// <param name="capacity">对象池的容量。</param>
  591. /// <param name="expireTime">对象池对象过期秒数。</param>
  592. /// <param name="priority">对象池的优先级。</param>
  593. /// <returns>要创建的允许多次获取的对象池。</returns>
  594. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime, int priority);
  595. /// <summary>
  596. /// 创建允许多次获取的对象池。
  597. /// </summary>
  598. /// <typeparam name="T">对象类型。</typeparam>
  599. /// <param name="name">对象池名称。</param>
  600. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  601. /// <param name="capacity">对象池的容量。</param>
  602. /// <param name="expireTime">对象池对象过期秒数。</param>
  603. /// <param name="priority">对象池的优先级。</param>
  604. /// <returns>要创建的允许多次获取的对象池。</returns>
  605. IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float autoReleaseInterval, int capacity, float expireTime, int priority) where T : ObjectBase;
  606. /// <summary>
  607. /// 创建允许多次获取的对象池。
  608. /// </summary>
  609. /// <param name="objectType">对象类型。</param>
  610. /// <param name="name">对象池名称。</param>
  611. /// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
  612. /// <param name="capacity">对象池的容量。</param>
  613. /// <param name="expireTime">对象池对象过期秒数。</param>
  614. /// <param name="priority">对象池的优先级。</param>
  615. /// <returns>要创建的允许多次获取的对象池。</returns>
  616. ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity, float expireTime, int priority);
  617. /// <summary>
  618. /// 销毁对象池。
  619. /// </summary>
  620. /// <typeparam name="T">对象类型。</typeparam>
  621. /// <returns>是否销毁对象池成功。</returns>
  622. bool DestroyObjectPool<T>() where T : ObjectBase;
  623. /// <summary>
  624. /// 销毁对象池。
  625. /// </summary>
  626. /// <param name="objectType">对象类型。</param>
  627. /// <returns>是否销毁对象池成功。</returns>
  628. bool DestroyObjectPool(Type objectType);
  629. /// <summary>
  630. /// 销毁对象池。
  631. /// </summary>
  632. /// <typeparam name="T">对象类型。</typeparam>
  633. /// <param name="name">要销毁的对象池名称。</param>
  634. /// <returns>是否销毁对象池成功。</returns>
  635. bool DestroyObjectPool<T>(string name) where T : ObjectBase;
  636. /// <summary>
  637. /// 销毁对象池。
  638. /// </summary>
  639. /// <param name="objectType">对象类型。</param>
  640. /// <param name="name">要销毁的对象池名称。</param>
  641. /// <returns>是否销毁对象池成功。</returns>
  642. bool DestroyObjectPool(Type objectType, string name);
  643. /// <summary>
  644. /// 销毁对象池。
  645. /// </summary>
  646. /// <typeparam name="T">对象类型。</typeparam>
  647. /// <param name="objectPool">要销毁的对象池。</param>
  648. /// <returns>是否销毁对象池成功。</returns>
  649. bool DestroyObjectPool<T>(IObjectPool<T> objectPool) where T : ObjectBase;
  650. /// <summary>
  651. /// 销毁对象池。
  652. /// </summary>
  653. /// <param name="objectPool">要销毁的对象池。</param>
  654. /// <returns>是否销毁对象池成功。</returns>
  655. bool DestroyObjectPool(ObjectPoolBase objectPool);
  656. /// <summary>
  657. /// 释放对象池中的可释放对象。
  658. /// </summary>
  659. void Release();
  660. /// <summary>
  661. /// 释放对象池中的所有未使用对象。
  662. /// </summary>
  663. void ReleaseAllUnused();
  664. }
  665. }