GameFrameworkSerializer.cs 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208
  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.Collections.Generic;
  8. using System.IO;
  9. namespace GameFramework
  10. {
  11. /// <summary>
  12. /// 游戏框架序列化器基类。
  13. /// </summary>
  14. /// <typeparam name="T">要序列化的数据类型。</typeparam>
  15. public abstract class GameFrameworkSerializer<T>
  16. {
  17. private readonly Dictionary<byte, SerializeCallback> m_SerializeCallbacks;
  18. private readonly Dictionary<byte, DeserializeCallback> m_DeserializeCallbacks;
  19. private readonly Dictionary<byte, TryGetValueCallback> m_TryGetValueCallbacks;
  20. private byte m_LatestSerializeCallbackVersion;
  21. /// <summary>
  22. /// 初始化游戏框架序列化器基类的新实例。
  23. /// </summary>
  24. public GameFrameworkSerializer()
  25. {
  26. m_SerializeCallbacks = new Dictionary<byte, SerializeCallback>();
  27. m_DeserializeCallbacks = new Dictionary<byte, DeserializeCallback>();
  28. m_TryGetValueCallbacks = new Dictionary<byte, TryGetValueCallback>();
  29. m_LatestSerializeCallbackVersion = 0;
  30. }
  31. /// <summary>
  32. /// 序列化回调函数。
  33. /// </summary>
  34. /// <param name="stream">目标流。</param>
  35. /// <param name="data">要序列化的数据。</param>
  36. /// <returns>是否序列化数据成功。</returns>
  37. public delegate bool SerializeCallback(Stream stream, T data);
  38. /// <summary>
  39. /// 反序列化回调函数。
  40. /// </summary>
  41. /// <param name="stream">指定流。</param>
  42. /// <returns>反序列化的数据。</returns>
  43. public delegate T DeserializeCallback(Stream stream);
  44. /// <summary>
  45. /// 尝试从指定流获取指定键的值回调函数。
  46. /// </summary>
  47. /// <param name="stream">指定流。</param>
  48. /// <param name="key">指定键。</param>
  49. /// <param name="value">指定键的值。</param>
  50. /// <returns>是否从指定流获取指定键的值成功。</returns>
  51. public delegate bool TryGetValueCallback(Stream stream, string key, out object value);
  52. /// <summary>
  53. /// 注册序列化回调函数。
  54. /// </summary>
  55. /// <param name="version">序列化回调函数的版本。</param>
  56. /// <param name="callback">序列化回调函数。</param>
  57. public void RegisterSerializeCallback(byte version, SerializeCallback callback)
  58. {
  59. if (callback == null)
  60. {
  61. throw new GameFrameworkException("Serialize callback is invalid.");
  62. }
  63. m_SerializeCallbacks[version] = callback;
  64. if (version > m_LatestSerializeCallbackVersion)
  65. {
  66. m_LatestSerializeCallbackVersion = version;
  67. }
  68. }
  69. /// <summary>
  70. /// 注册反序列化回调函数。
  71. /// </summary>
  72. /// <param name="version">反序列化回调函数的版本。</param>
  73. /// <param name="callback">反序列化回调函数。</param>
  74. public void RegisterDeserializeCallback(byte version, DeserializeCallback callback)
  75. {
  76. if (callback == null)
  77. {
  78. throw new GameFrameworkException("Deserialize callback is invalid.");
  79. }
  80. m_DeserializeCallbacks[version] = callback;
  81. }
  82. /// <summary>
  83. /// 注册尝试从指定流获取指定键的值回调函数。
  84. /// </summary>
  85. /// <param name="version">尝试从指定流获取指定键的值回调函数的版本。</param>
  86. /// <param name="callback">尝试从指定流获取指定键的值回调函数。</param>
  87. public void RegisterTryGetValueCallback(byte version, TryGetValueCallback callback)
  88. {
  89. if (callback == null)
  90. {
  91. throw new GameFrameworkException("Try get value callback is invalid.");
  92. }
  93. m_TryGetValueCallbacks[version] = callback;
  94. }
  95. /// <summary>
  96. /// 序列化数据到目标流中。
  97. /// </summary>
  98. /// <param name="stream">目标流。</param>
  99. /// <param name="data">要序列化的数据。</param>
  100. /// <returns>是否序列化数据成功。</returns>
  101. public bool Serialize(Stream stream, T data)
  102. {
  103. if (m_SerializeCallbacks.Count <= 0)
  104. {
  105. throw new GameFrameworkException("No serialize callback registered.");
  106. }
  107. return Serialize(stream, data, m_LatestSerializeCallbackVersion);
  108. }
  109. /// <summary>
  110. /// 序列化数据到目标流中。
  111. /// </summary>
  112. /// <param name="stream">目标流。</param>
  113. /// <param name="data">要序列化的数据。</param>
  114. /// <param name="version">序列化回调函数的版本。</param>
  115. /// <returns>是否序列化数据成功。</returns>
  116. public bool Serialize(Stream stream, T data, byte version)
  117. {
  118. byte[] header = GetHeader();
  119. stream.WriteByte(header[0]);
  120. stream.WriteByte(header[1]);
  121. stream.WriteByte(header[2]);
  122. stream.WriteByte(version);
  123. SerializeCallback callback = null;
  124. if (!m_SerializeCallbacks.TryGetValue(version, out callback))
  125. {
  126. throw new GameFrameworkException(Utility.Text.Format("Serialize callback '{0}' is not exist.", version));
  127. }
  128. return callback(stream, data);
  129. }
  130. /// <summary>
  131. /// 从指定流反序列化数据。
  132. /// </summary>
  133. /// <param name="stream">指定流。</param>
  134. /// <returns>反序列化的数据。</returns>
  135. public T Deserialize(Stream stream)
  136. {
  137. byte[] header = GetHeader();
  138. byte header0 = (byte)stream.ReadByte();
  139. byte header1 = (byte)stream.ReadByte();
  140. byte header2 = (byte)stream.ReadByte();
  141. if (header0 != header[0] || header1 != header[1] || header2 != header[2])
  142. {
  143. throw new GameFrameworkException(Utility.Text.Format("Header is invalid, need '{0}{1}{2}', current '{3}{4}{5}'.", (char)header[0], (char)header[1], (char)header[2], (char)header0, (char)header1, (char)header2));
  144. }
  145. byte version = (byte)stream.ReadByte();
  146. DeserializeCallback callback = null;
  147. if (!m_DeserializeCallbacks.TryGetValue(version, out callback))
  148. {
  149. throw new GameFrameworkException(Utility.Text.Format("Deserialize callback '{0}' is not exist.", version));
  150. }
  151. return callback(stream);
  152. }
  153. /// <summary>
  154. /// 尝试从指定流获取指定键的值。
  155. /// </summary>
  156. /// <param name="stream">指定流。</param>
  157. /// <param name="key">指定键。</param>
  158. /// <param name="value">指定键的值。</param>
  159. /// <returns>是否从指定流获取指定键的值成功。</returns>
  160. public bool TryGetValue(Stream stream, string key, out object value)
  161. {
  162. value = null;
  163. byte[] header = GetHeader();
  164. byte header0 = (byte)stream.ReadByte();
  165. byte header1 = (byte)stream.ReadByte();
  166. byte header2 = (byte)stream.ReadByte();
  167. if (header0 != header[0] || header1 != header[1] || header2 != header[2])
  168. {
  169. return false;
  170. }
  171. byte version = (byte)stream.ReadByte();
  172. TryGetValueCallback callback = null;
  173. if (!m_TryGetValueCallbacks.TryGetValue(version, out callback))
  174. {
  175. return false;
  176. }
  177. return callback(stream, key, out value);
  178. }
  179. /// <summary>
  180. /// 获取数据头标识。
  181. /// </summary>
  182. /// <returns>数据头标识。</returns>
  183. protected abstract byte[] GetHeader();
  184. }
  185. }