DataTableManager.cs 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508
  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.Resource;
  8. using System;
  9. using System.Collections.Generic;
  10. namespace GameFramework.DataTable
  11. {
  12. /// <summary>
  13. /// 数据表管理器。
  14. /// </summary>
  15. internal sealed partial class DataTableManager : GameFrameworkModule, IDataTableManager
  16. {
  17. private readonly Dictionary<TypeNamePair, DataTableBase> m_DataTables;
  18. private IResourceManager m_ResourceManager;
  19. private IDataProviderHelper<DataTableBase> m_DataProviderHelper;
  20. private IDataTableHelper m_DataTableHelper;
  21. /// <summary>
  22. /// 初始化数据表管理器的新实例。
  23. /// </summary>
  24. public DataTableManager()
  25. {
  26. m_DataTables = new Dictionary<TypeNamePair, DataTableBase>();
  27. m_ResourceManager = null;
  28. m_DataProviderHelper = null;
  29. m_DataTableHelper = null;
  30. }
  31. /// <summary>
  32. /// 获取数据表数量。
  33. /// </summary>
  34. public int Count
  35. {
  36. get
  37. {
  38. return m_DataTables.Count;
  39. }
  40. }
  41. /// <summary>
  42. /// 获取缓冲二进制流的大小。
  43. /// </summary>
  44. public int CachedBytesSize
  45. {
  46. get
  47. {
  48. return DataProvider<DataTableBase>.CachedBytesSize;
  49. }
  50. }
  51. /// <summary>
  52. /// 数据表管理器轮询。
  53. /// </summary>
  54. /// <param name="elapseSeconds">逻辑流逝时间,以秒为单位。</param>
  55. /// <param name="realElapseSeconds">真实流逝时间,以秒为单位。</param>
  56. internal override void Update(float elapseSeconds, float realElapseSeconds)
  57. {
  58. }
  59. /// <summary>
  60. /// 关闭并清理数据表管理器。
  61. /// </summary>
  62. internal override void Shutdown()
  63. {
  64. foreach (KeyValuePair<TypeNamePair, DataTableBase> dataTable in m_DataTables)
  65. {
  66. dataTable.Value.Shutdown();
  67. }
  68. m_DataTables.Clear();
  69. }
  70. /// <summary>
  71. /// 设置资源管理器。
  72. /// </summary>
  73. /// <param name="resourceManager">资源管理器。</param>
  74. public void SetResourceManager(IResourceManager resourceManager)
  75. {
  76. if (resourceManager == null)
  77. {
  78. throw new GameFrameworkException("Resource manager is invalid.");
  79. }
  80. m_ResourceManager = resourceManager;
  81. }
  82. /// <summary>
  83. /// 设置数据表数据提供者辅助器。
  84. /// </summary>
  85. /// <param name="dataProviderHelper">数据表数据提供者辅助器。</param>
  86. public void SetDataProviderHelper(IDataProviderHelper<DataTableBase> dataProviderHelper)
  87. {
  88. if (dataProviderHelper == null)
  89. {
  90. throw new GameFrameworkException("Data provider helper is invalid.");
  91. }
  92. m_DataProviderHelper = dataProviderHelper;
  93. }
  94. /// <summary>
  95. /// 设置数据表辅助器。
  96. /// </summary>
  97. /// <param name="dataTableHelper">数据表辅助器。</param>
  98. public void SetDataTableHelper(IDataTableHelper dataTableHelper)
  99. {
  100. if (dataTableHelper == null)
  101. {
  102. throw new GameFrameworkException("Data table helper is invalid.");
  103. }
  104. m_DataTableHelper = dataTableHelper;
  105. }
  106. /// <summary>
  107. /// 确保二进制流缓存分配足够大小的内存并缓存。
  108. /// </summary>
  109. /// <param name="ensureSize">要确保二进制流缓存分配内存的大小。</param>
  110. public void EnsureCachedBytesSize(int ensureSize)
  111. {
  112. DataProvider<DataTableBase>.EnsureCachedBytesSize(ensureSize);
  113. }
  114. /// <summary>
  115. /// 释放缓存的二进制流。
  116. /// </summary>
  117. public void FreeCachedBytes()
  118. {
  119. DataProvider<DataTableBase>.FreeCachedBytes();
  120. }
  121. /// <summary>
  122. /// 是否存在数据表。
  123. /// </summary>
  124. /// <typeparam name="T">数据表行的类型。</typeparam>
  125. /// <returns>是否存在数据表。</returns>
  126. public bool HasDataTable<T>() where T : IDataRow
  127. {
  128. return InternalHasDataTable(new TypeNamePair(typeof(T)));
  129. }
  130. /// <summary>
  131. /// 是否存在数据表。
  132. /// </summary>
  133. /// <param name="dataRowType">数据表行的类型。</param>
  134. /// <returns>是否存在数据表。</returns>
  135. public bool HasDataTable(Type dataRowType)
  136. {
  137. if (dataRowType == null)
  138. {
  139. throw new GameFrameworkException("Data row type is invalid.");
  140. }
  141. if (!typeof(IDataRow).IsAssignableFrom(dataRowType))
  142. {
  143. throw new GameFrameworkException(Utility.Text.Format("Data row type '{0}' is invalid.", dataRowType.FullName));
  144. }
  145. return InternalHasDataTable(new TypeNamePair(dataRowType));
  146. }
  147. /// <summary>
  148. /// 是否存在数据表。
  149. /// </summary>
  150. /// <typeparam name="T">数据表行的类型。</typeparam>
  151. /// <param name="name">数据表名称。</param>
  152. /// <returns>是否存在数据表。</returns>
  153. public bool HasDataTable<T>(string name) where T : IDataRow
  154. {
  155. return InternalHasDataTable(new TypeNamePair(typeof(T), name));
  156. }
  157. /// <summary>
  158. /// 是否存在数据表。
  159. /// </summary>
  160. /// <param name="dataRowType">数据表行的类型。</param>
  161. /// <param name="name">数据表名称。</param>
  162. /// <returns>是否存在数据表。</returns>
  163. public bool HasDataTable(Type dataRowType, string name)
  164. {
  165. if (dataRowType == null)
  166. {
  167. throw new GameFrameworkException("Data row type is invalid.");
  168. }
  169. if (!typeof(IDataRow).IsAssignableFrom(dataRowType))
  170. {
  171. throw new GameFrameworkException(Utility.Text.Format("Data row type '{0}' is invalid.", dataRowType.FullName));
  172. }
  173. return InternalHasDataTable(new TypeNamePair(dataRowType, name));
  174. }
  175. /// <summary>
  176. /// 获取数据表。
  177. /// </summary>
  178. /// <typeparam name="T">数据表行的类型。</typeparam>
  179. /// <returns>要获取的数据表。</returns>
  180. public IDataTable<T> GetDataTable<T>() where T : IDataRow
  181. {
  182. return (IDataTable<T>)InternalGetDataTable(new TypeNamePair(typeof(T)));
  183. }
  184. /// <summary>
  185. /// 获取数据表。
  186. /// </summary>
  187. /// <param name="dataRowType">数据表行的类型。</param>
  188. /// <returns>要获取的数据表。</returns>
  189. public DataTableBase GetDataTable(Type dataRowType)
  190. {
  191. if (dataRowType == null)
  192. {
  193. throw new GameFrameworkException("Data row type is invalid.");
  194. }
  195. if (!typeof(IDataRow).IsAssignableFrom(dataRowType))
  196. {
  197. throw new GameFrameworkException(Utility.Text.Format("Data row type '{0}' is invalid.", dataRowType.FullName));
  198. }
  199. return InternalGetDataTable(new TypeNamePair(dataRowType));
  200. }
  201. /// <summary>
  202. /// 获取数据表。
  203. /// </summary>
  204. /// <typeparam name="T">数据表行的类型。</typeparam>
  205. /// <param name="name">数据表名称。</param>
  206. /// <returns>要获取的数据表。</returns>
  207. public IDataTable<T> GetDataTable<T>(string name) where T : IDataRow
  208. {
  209. return (IDataTable<T>)InternalGetDataTable(new TypeNamePair(typeof(T), name));
  210. }
  211. /// <summary>
  212. /// 获取数据表。
  213. /// </summary>
  214. /// <param name="dataRowType">数据表行的类型。</param>
  215. /// <param name="name">数据表名称。</param>
  216. /// <returns>要获取的数据表。</returns>
  217. public DataTableBase GetDataTable(Type dataRowType, string name)
  218. {
  219. if (dataRowType == null)
  220. {
  221. throw new GameFrameworkException("Data row type is invalid.");
  222. }
  223. if (!typeof(IDataRow).IsAssignableFrom(dataRowType))
  224. {
  225. throw new GameFrameworkException(Utility.Text.Format("Data row type '{0}' is invalid.", dataRowType.FullName));
  226. }
  227. return InternalGetDataTable(new TypeNamePair(dataRowType, name));
  228. }
  229. /// <summary>
  230. /// 获取所有数据表。
  231. /// </summary>
  232. /// <returns>所有数据表。</returns>
  233. public DataTableBase[] GetAllDataTables()
  234. {
  235. int index = 0;
  236. DataTableBase[] results = new DataTableBase[m_DataTables.Count];
  237. foreach (KeyValuePair<TypeNamePair, DataTableBase> dataTable in m_DataTables)
  238. {
  239. results[index++] = dataTable.Value;
  240. }
  241. return results;
  242. }
  243. /// <summary>
  244. /// 获取所有数据表。
  245. /// </summary>
  246. /// <param name="results">所有数据表。</param>
  247. public void GetAllDataTables(List<DataTableBase> results)
  248. {
  249. if (results == null)
  250. {
  251. throw new GameFrameworkException("Results is invalid.");
  252. }
  253. results.Clear();
  254. foreach (KeyValuePair<TypeNamePair, DataTableBase> dataTable in m_DataTables)
  255. {
  256. results.Add(dataTable.Value);
  257. }
  258. }
  259. /// <summary>
  260. /// 创建数据表。
  261. /// </summary>
  262. /// <typeparam name="T">数据表行的类型。</typeparam>
  263. /// <returns>要创建的数据表。</returns>
  264. public IDataTable<T> CreateDataTable<T>() where T : class, IDataRow, new()
  265. {
  266. return CreateDataTable<T>(string.Empty);
  267. }
  268. /// <summary>
  269. /// 创建数据表。
  270. /// </summary>
  271. /// <param name="dataRowType">数据表行的类型。</param>
  272. /// <returns>要创建的数据表。</returns>
  273. public DataTableBase CreateDataTable(Type dataRowType)
  274. {
  275. return CreateDataTable(dataRowType, string.Empty);
  276. }
  277. /// <summary>
  278. /// 创建数据表。
  279. /// </summary>
  280. /// <typeparam name="T">数据表行的类型。</typeparam>
  281. /// <param name="name">数据表名称。</param>
  282. /// <returns>要创建的数据表。</returns>
  283. public IDataTable<T> CreateDataTable<T>(string name) where T : class, IDataRow, new()
  284. {
  285. if (m_ResourceManager == null)
  286. {
  287. throw new GameFrameworkException("You must set resource manager first.");
  288. }
  289. if (m_DataProviderHelper == null)
  290. {
  291. throw new GameFrameworkException("You must set data provider helper first.");
  292. }
  293. TypeNamePair typeNamePair = new TypeNamePair(typeof(T), name);
  294. if (HasDataTable<T>(name))
  295. {
  296. throw new GameFrameworkException(Utility.Text.Format("Already exist data table '{0}'.", typeNamePair));
  297. }
  298. DataTable<T> dataTable = new DataTable<T>(name);
  299. dataTable.SetResourceManager(m_ResourceManager);
  300. dataTable.SetDataProviderHelper(m_DataProviderHelper);
  301. m_DataTables.Add(typeNamePair, dataTable);
  302. return dataTable;
  303. }
  304. /// <summary>
  305. /// 创建数据表。
  306. /// </summary>
  307. /// <param name="dataRowType">数据表行的类型。</param>
  308. /// <param name="name">数据表名称。</param>
  309. /// <returns>要创建的数据表。</returns>
  310. public DataTableBase CreateDataTable(Type dataRowType, string name)
  311. {
  312. if (m_ResourceManager == null)
  313. {
  314. throw new GameFrameworkException("You must set resource manager first.");
  315. }
  316. if (m_DataProviderHelper == null)
  317. {
  318. throw new GameFrameworkException("You must set data provider helper first.");
  319. }
  320. if (dataRowType == null)
  321. {
  322. throw new GameFrameworkException("Data row type is invalid.");
  323. }
  324. if (!typeof(IDataRow).IsAssignableFrom(dataRowType))
  325. {
  326. throw new GameFrameworkException(Utility.Text.Format("Data row type '{0}' is invalid.", dataRowType.FullName));
  327. }
  328. TypeNamePair typeNamePair = new TypeNamePair(dataRowType, name);
  329. if (HasDataTable(dataRowType, name))
  330. {
  331. throw new GameFrameworkException(Utility.Text.Format("Already exist data table '{0}'.", typeNamePair));
  332. }
  333. Type dataTableType = typeof(DataTable<>).MakeGenericType(dataRowType);
  334. DataTableBase dataTable = (DataTableBase)Activator.CreateInstance(dataTableType, name);
  335. dataTable.SetResourceManager(m_ResourceManager);
  336. dataTable.SetDataProviderHelper(m_DataProviderHelper);
  337. m_DataTables.Add(typeNamePair, dataTable);
  338. return dataTable;
  339. }
  340. /// <summary>
  341. /// 销毁数据表。
  342. /// </summary>
  343. /// <typeparam name="T">数据表行的类型。</typeparam>
  344. public bool DestroyDataTable<T>() where T : IDataRow
  345. {
  346. return InternalDestroyDataTable(new TypeNamePair(typeof(T)));
  347. }
  348. /// <summary>
  349. /// 销毁数据表。
  350. /// </summary>
  351. /// <param name="dataRowType">数据表行的类型。</param>
  352. /// <returns>是否销毁数据表成功。</returns>
  353. public bool DestroyDataTable(Type dataRowType)
  354. {
  355. if (dataRowType == null)
  356. {
  357. throw new GameFrameworkException("Data row type is invalid.");
  358. }
  359. if (!typeof(IDataRow).IsAssignableFrom(dataRowType))
  360. {
  361. throw new GameFrameworkException(Utility.Text.Format("Data row type '{0}' is invalid.", dataRowType.FullName));
  362. }
  363. return InternalDestroyDataTable(new TypeNamePair(dataRowType));
  364. }
  365. /// <summary>
  366. /// 销毁数据表。
  367. /// </summary>
  368. /// <typeparam name="T">数据表行的类型。</typeparam>
  369. /// <param name="name">数据表名称。</param>
  370. public bool DestroyDataTable<T>(string name) where T : IDataRow
  371. {
  372. return InternalDestroyDataTable(new TypeNamePair(typeof(T), name));
  373. }
  374. /// <summary>
  375. /// 销毁数据表。
  376. /// </summary>
  377. /// <param name="dataRowType">数据表行的类型。</param>
  378. /// <param name="name">数据表名称。</param>
  379. /// <returns>是否销毁数据表成功。</returns>
  380. public bool DestroyDataTable(Type dataRowType, string name)
  381. {
  382. if (dataRowType == null)
  383. {
  384. throw new GameFrameworkException("Data row type is invalid.");
  385. }
  386. if (!typeof(IDataRow).IsAssignableFrom(dataRowType))
  387. {
  388. throw new GameFrameworkException(Utility.Text.Format("Data row type '{0}' is invalid.", dataRowType.FullName));
  389. }
  390. return InternalDestroyDataTable(new TypeNamePair(dataRowType, name));
  391. }
  392. /// <summary>
  393. /// 销毁数据表。
  394. /// </summary>
  395. /// <typeparam name="T">数据表行的类型。</typeparam>
  396. /// <param name="dataTable">要销毁的数据表。</param>
  397. /// <returns>是否销毁数据表成功。</returns>
  398. public bool DestroyDataTable<T>(IDataTable<T> dataTable) where T : IDataRow
  399. {
  400. if (dataTable == null)
  401. {
  402. throw new GameFrameworkException("Data table is invalid.");
  403. }
  404. return InternalDestroyDataTable(new TypeNamePair(typeof(T), dataTable.Name));
  405. }
  406. /// <summary>
  407. /// 销毁数据表。
  408. /// </summary>
  409. /// <param name="dataTable">要销毁的数据表。</param>
  410. /// <returns>是否销毁数据表成功。</returns>
  411. public bool DestroyDataTable(DataTableBase dataTable)
  412. {
  413. if (dataTable == null)
  414. {
  415. throw new GameFrameworkException("Data table is invalid.");
  416. }
  417. return InternalDestroyDataTable(new TypeNamePair(dataTable.Type, dataTable.Name));
  418. }
  419. private bool InternalHasDataTable(TypeNamePair typeNamePair)
  420. {
  421. return m_DataTables.ContainsKey(typeNamePair);
  422. }
  423. private DataTableBase InternalGetDataTable(TypeNamePair typeNamePair)
  424. {
  425. DataTableBase dataTable = null;
  426. if (m_DataTables.TryGetValue(typeNamePair, out dataTable))
  427. {
  428. return dataTable;
  429. }
  430. return null;
  431. }
  432. private bool InternalDestroyDataTable(TypeNamePair typeNamePair)
  433. {
  434. DataTableBase dataTable = null;
  435. if (m_DataTables.TryGetValue(typeNamePair, out dataTable))
  436. {
  437. dataTable.Shutdown();
  438. return m_DataTables.Remove(typeNamePair);
  439. }
  440. return false;
  441. }
  442. }
  443. }