1.完善组包的长度校验

2.完善指令消息注释

src/JT808.Protocol.Test/MessageBody/JT808_0x0608Test.cs

@@ -295,7 +295,7 @@ namespace JT808.Protocol.Test.MessageBody
             Assert.Equal(DateTime.Parse("2020-01-07 00:00:12"), jT808_0X8606.StartTime);
             Assert.Equal(DateTime.Parse("2020-01-07 00:00:12"), jT808_0X8606.EndTime);
 
-            Assert.Equal(1, jT808_0X8606.InflectionPointItems.Count);
+            Assert.Single(jT808_0X8606.InflectionPointItems);
 
             Assert.Equal((uint)1000, jT808_0X8606.InflectionPointItems[0].InflectionPointId);
             Assert.Equal((uint)123456789, jT808_0X8606.InflectionPointItems[0].InflectionPointLat);

src/JT808.Protocol/DependencyInjectionExtensions.cs

@@ -8,36 +8,61 @@ using System.Text;
 namespace JT808.Protocol
 {
     /// <summary>
-    /// 
+    /// DI扩展
     /// </summary>
     public static class DependencyInjectionExtensions
     {
+        /// <summary>
+        /// 注册808配置
+        /// </summary>
+        /// <param name="services"></param>
+        /// <param name="jT808Config"></param>
+        /// <returns></returns>
         public static IJT808Builder AddJT808Configure(this IServiceCollection services, IJT808Config jT808Config)
         {
             services.AddSingleton(jT808Config.GetType(), jT808Config);
             return new DefaultBuilder(services, jT808Config);
         }
-
+        /// <summary>
+        /// 注册808配置
+        /// </summary>
+        /// <param name="builder"></param>
+        /// <param name="jT808Config"></param>
+        /// <returns></returns>
         public static IJT808Builder AddJT808Configure(this IJT808Builder builder, IJT808Config jT808Config)
         {
             builder.Services.AddSingleton(jT808Config.GetType(), jT808Config);
             return builder;
         }
-
+        /// <summary>
+        /// 注册808配置
+        /// </summary>
+        /// <typeparam name="TJT808Config"></typeparam>
+        /// <param name="services"></param>
+        /// <returns></returns>
         public static IJT808Builder AddJT808Configure<TJT808Config>(this IServiceCollection services)where TJT808Config : IJT808Config,new()
         {
             var config = new TJT808Config();
             services.AddSingleton(typeof(TJT808Config), config);
             return new DefaultBuilder(services, config);
         }
-
+        /// <summary>
+        /// 注册808配置
+        /// </summary>
+        /// <typeparam name="TJT808Config"></typeparam>
+        /// <param name="builder"></param>
+        /// <returns></returns>
         public static IJT808Builder AddJT808Configure<TJT808Config>(this IJT808Builder builder) where TJT808Config : IJT808Config, new()
         {
             var config = new TJT808Config();
             builder.Services.AddSingleton(typeof(TJT808Config), config);
             return builder;
         }
-
+        /// <summary>
+        /// 注册808配置
+        /// </summary>
+        /// <param name="services"></param>
+        /// <returns></returns>
         public static IJT808Builder AddJT808Configure(this IServiceCollection services)
         {
             DefaultGlobalConfig config = new DefaultGlobalConfig();

src/JT808.Protocol/Enums/JT808Alarm.cs

@@ -85,8 +85,17 @@ namespace JT808.Protocol.Enums
         /// 标志维持至报警条件解除
         /// </summary>
         疲劳驾驶预警 = 16384,
+        /// <summary>
+        /// 保留1
+        /// </summary>
         保留1 = 32768,
+        /// <summary>
+        /// 保留2
+        /// </summary>
         保留2 = 65536,
+        /// <summary>
+        /// 保留3
+        /// </summary>
         保留3 = 131072,
         /// <summary>
         /// 当天累计驾驶超时

src/JT808.Protocol/Enums/JT808CallBackType.cs

@@ -5,7 +5,13 @@
     /// </summary>
     public enum JT808CallBackType : byte
     {
+        /// <summary>
+        /// 普通通话
+        /// </summary>
         普通通话 = 0,
+        /// <summary>
+        /// 监听
+        /// </summary>
         监听 = 1
     }
 }

src/JT808.Protocol/Enums/JT808CameraResolutionType.cs

@@ -9,13 +9,37 @@ namespace JT808.Protocol.Enums
     /// </summary>
     public enum JT808CameraResolutionType:byte
     {
+        /// <summary>
+        /// x320_240
+        /// </summary>
         x320_240 = 0x01,
+        /// <summary>
+        /// x640_480
+        /// </summary>
         x640_480 = 0x02,
+        /// <summary>
+        /// x800_600
+        /// </summary>
         x800_600 = 0x03,
+        /// <summary>
+        /// x1020_768
+        /// </summary>
         x1020_768 = 0x04,
+        /// <summary>
+        /// x176_144_Qcif
+        /// </summary>
         x176_144_Qcif = 0x05,
+        /// <summary>
+        /// x352_288_Cif
+        /// </summary>
         x352_288_Cif = 0x06,
+        /// <summary>
+        /// x704_288_HALF_D1
+        /// </summary>
         x704_288_HALF_D1 = 0x07,
+        /// <summary>
+        /// x704_576_D1
+        /// </summary>
         x704_576_D1 = 0x07,
     }
 }

src/JT808.Protocol/Enums/JT808DirectionType.cs

@@ -5,7 +5,13 @@
     /// </summary>
     public enum JT808DirectionType : byte
     {
+        /// <summary>
+        /// 进
+        /// </summary>
         进 = 0,
+        /// <summary>
+        /// 出
+        /// </summary>
         出 = 1
     }
 }

src/JT808.Protocol/Enums/JT808ErrorCode.cs

@@ -1,5 +1,8 @@
 namespace JT808.Protocol.Enums
 {
+    /// <summary>
+    /// 异常错误码
+    /// </summary>
     public enum JT808ErrorCode
     {
         /// <summary>

src/JT808.Protocol/Enums/JT808TelephoneBookContactType.cs

@@ -5,8 +5,17 @@
     /// </summary>
     public enum JT808TelephoneBookContactType : byte
     {
+        /// <summary>
+        /// 呼入
+        /// </summary>
         呼入 = 1,
+        /// <summary>
+        /// 呼出
+        /// </summary>
         呼出 = 2,
+        /// <summary>
+        /// 呼入_呼出
+        /// </summary>
         呼入_呼出 = 3
     }
 }

src/JT808.Protocol/Enums/JT808TerminalRegisterResult.cs

@@ -1,11 +1,29 @@
 namespace JT808.Protocol.Enums
 {
+    /// <summary>
+    /// 终端注册返回结果
+    /// </summary>
     public enum JT808TerminalRegisterResult : byte
     {
+        /// <summary>
+        /// 成功
+        /// </summary>
         成功 = 0x00,
+        /// <summary>
+        /// 车辆已被注册
+        /// </summary>
         车辆已被注册 = 0x01,
+        /// <summary>
+        /// 数据库中无该车辆
+        /// </summary>
         数据库中无该车辆 = 0x02,
+        /// <summary>
+        /// 终端已被注册
+        /// </summary>
         终端已被注册 = 0x03,
+        /// <summary>
+        /// 数据库中无该终端
+        /// </summary>
         数据库中无该终端 = 0x04
     }
 }

src/JT808.Protocol/Enums/JT808TerminalResult.cs

@@ -1,5 +1,8 @@
 namespace JT808.Protocol.Enums
 {
+    /// <summary>
+    /// 通用应答返回
+    /// </summary>
     public enum JT808TerminalResult : byte
     {
         /// <summary>

src/JT808.Protocol/Extensions/JT808MessagePackFormatterResolverExtensions.cs

@@ -23,6 +23,13 @@ namespace JT808.Protocol.Extensions
         static readonly ConcurrentDictionary<Type, (object Value, JT808SerializeMethod SerializeMethod)> jT808Serializers = new ConcurrentDictionary<Type, (object Value, JT808SerializeMethod SerializeMethod)>();
         
         static readonly ConcurrentDictionary<Type, (object Value, JT808DeserializeMethod DeserializeMethod)> jT808Deserializes = new ConcurrentDictionary<Type, (object Value, JT808DeserializeMethod DeserializeMethod)>();
+        /// <summary>
+        /// JT808动态序列化
+        /// </summary>
+        /// <param name="objFormatter"></param>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public static void JT808DynamicSerialize(object objFormatter, ref JT808MessagePackWriter writer, object value, IJT808Config config)
         {
             Type type = value.GetType();
@@ -51,6 +58,13 @@ namespace JT808.Protocol.Extensions
             }
             formatterAndDelegate.SerializeMethod(formatterAndDelegate.Value, ref writer, value, config);
         }
+        /// <summary>
+        /// JT808动态反序列化
+        /// </summary>
+        /// <param name="objFormatter"></param>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public static dynamic JT808DynamicDeserialize(object objFormatter, ref JT808MessagePackReader reader, IJT808Config config)
         {
             var type = objFormatter.GetType();

src/JT808.Protocol/Extensions/JT808ValidationExtensions.cs

@@ -32,9 +32,9 @@ namespace JT808.Protocol.Extensions
         /// <param name="maxLength"></param>
         public static string ValiMaxString(this string value, in string fieldName, in int maxLength)
         {
-            if (length > maxLength)
+            if (value.Length > maxLength)
             {
-                throw new JT808Exception(JT808ErrorCode.VailLength, $"{fieldName}:{length}>max length[{maxLength}]");
+                throw new JT808Exception(JT808ErrorCode.VailLength, $"{fieldName}:{value.Length}>max length[{maxLength}]");
             }
             return value;
         }

src/JT808.Protocol/IJT808Builder.cs

@@ -6,9 +6,18 @@ using System.Text;
 
 namespace JT808.Protocol
 {
+    /// <summary>
+    /// JT808构造器
+    /// </summary>
     public interface IJT808Builder
     {
+        /// <summary>
+        /// JT808配置
+        /// </summary>
         IJT808Config Config { get; }
+        /// <summary>
+        /// 服务注册
+        /// </summary>
         IServiceCollection Services { get; }
     }
 }

src/JT808.Protocol/Interfaces/GlobalConfigBase.cs

@@ -7,8 +7,14 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 全局配置基类
+    /// </summary>
     public abstract class GlobalConfigBase : IJT808Config
     {
+        /// <summary>
+        /// 
+        /// </summary>
         protected GlobalConfigBase()
         {
             Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
@@ -31,26 +37,93 @@ namespace JT808.Protocol.Interfaces
             TerminalPhoneNoLength = 12;
             Trim = true;
         }
+        /// <summary>
+        /// 配置Id
+        /// </summary>
         public abstract string ConfigId { get; protected set; }
+        /// <summary>
+        /// 分布式消息自增流水号
+        /// </summary>
         public virtual IJT808MsgSNDistributed MsgSNDistributed { get; set; }
+        /// <summary>
+        /// 压缩
+        /// </summary>
         public virtual IJT808Compress Compress { get; set; }
+        /// <summary>
+        /// 808分包策略
+        /// </summary>
         public virtual IJT808SplitPackageStrategy SplitPackageStrategy { get; set; }
+        /// <summary>
+        /// 808消息Id工厂
+        /// </summary>
         public virtual IJT808MsgIdFactory MsgIdFactory { get; set; }
+        /// <summary>
+        /// GBK编码
+        /// </summary>
         public virtual Encoding Encoding { get; set; }
+        /// <summary>
+        /// 跳过校验码验证
+        /// 默认false
+        /// </summary>
         public virtual bool SkipCRCCode { get; set; }
+        /// <summary>
+        /// 序列化器工厂
+        /// </summary>
         public virtual IJT808FormatterFactory FormatterFactory { get; set; }
+        /// <summary>
+        /// 0x0200自定义附加信息工厂
+        /// </summary>
         public virtual IJT808_0x0200_Custom_Factory JT808_0X0200_Custom_Factory { get; set; }
+        /// <summary>
+        /// 0x0200附加信息工厂
+        /// </summary>
         public virtual IJT808_0x0200_Factory JT808_0X0200_Factory { get; set; }
+        /// <summary>
+        /// 0x8103自定义终端参数设置自定义消息工厂
+        /// </summary>
         public virtual IJT808_0x8103_Custom_Factory JT808_0X8103_Custom_Factory { get; set; }
+        /// <summary>
+        /// 0x8103终端参数设置消息工厂
+        /// </summary>
         public virtual IJT808_0x8103_Factory JT808_0X8103_Factory { get; set; }
+        /// <summary>
+        /// 终端SIM卡长度
+        /// </summary>
         public virtual int TerminalPhoneNoLength { get; set; }
+        /// <summary>
+        /// 是否去掉头尾空格
+        /// </summary>
         public virtual bool Trim { get; set; }
+        /// <summary>
+        /// 自定义数据上行透传消息工厂
+        /// </summary>
         public virtual IJT808_0x0900_Custom_Factory JT808_0x0900_Custom_Factory { get; set; }
+        /// <summary>
+        /// 自定义数据下行透传消息工厂
+        /// </summary>
         public virtual IJT808_0x8900_Custom_Factory JT808_0x8900_Custom_Factory { get; set; }
+        /// <summary>
+        /// 车辆控制消息工厂
+        /// </summary>
         public virtual IJT808_0x8500_2019_Factory JT808_0x8500_2019_Factory { get; set; }
+        /// <summary>
+        /// JT19056上行消息工厂
+        /// </summary>
         public IJT808_CarDVR_Up_Factory JT808_CarDVR_Up_Factory { get; set; }
+        /// <summary>
+        /// JT19056下行消息工厂
+        /// </summary>
         public IJT808_CarDVR_Down_Factory JT808_CarDVR_Down_Factory { get; set; }
+        /// <summary>
+        /// 跳过校验码验证
+        /// 默认false
+        /// </summary>
         public bool SkipCarDVRCRCCode { get; set; }
+        /// <summary>
+        /// 外部扩展程序集注册
+        /// </summary>
+        /// <param name="externalAssemblies"></param>
+        /// <returns></returns>
         public virtual IJT808Config Register(params Assembly[] externalAssemblies)
         {
             if (externalAssemblies != null)

src/JT808.Protocol/Interfaces/IJT808Analyze.cs

@@ -4,8 +4,17 @@ using System.Text.Json;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// JT808分析器
+    /// </summary>
     public interface IJT808Analyze
     {
+        /// <summary>
+        /// 分析器
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config);
     }
 }

src/JT808.Protocol/Interfaces/IJT808Compress.cs

@@ -5,7 +5,17 @@
     /// </summary>
     public interface IJT808Compress
     {
+        /// <summary>
+        /// 压缩
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
         byte[] Compress(byte[] data);
+        /// <summary>
+        /// 解压缩
+        /// </summary>
+        /// <param name="compressData"></param>
+        /// <returns></returns>
 
         byte[] Decompress(byte[] compressData);
     }

src/JT808.Protocol/Interfaces/IJT808Config.cs

@@ -8,6 +8,9 @@ using System.Text;
 
 namespace JT808.Protocol
 {
+    /// <summary>
+    /// JT808接口配置
+    /// </summary>
     public interface IJT808Config
     {
         /// <summary>

src/JT808.Protocol/Interfaces/IJT808Description.cs

@@ -4,8 +4,14 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 消息描述接口
+    /// </summary>
     public interface IJT808Description
     {
+        /// <summary>
+        /// 消息描述
+        /// </summary>
         string Description { get;}
     }
 }

src/JT808.Protocol/Interfaces/IJT808MsgIdFactory.cs

@@ -3,10 +3,27 @@ using System.Collections.Generic;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// JT808消息工厂接口
+    /// </summary>
     public interface IJT808MsgIdFactory:IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<ushort, object> Map { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="msgId"></param>
+        /// <param name="instance"></param>
+        /// <returns></returns>
         bool TryGetValue(ushort msgId, out object instance);
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808Bodies"></typeparam>
+        /// <returns></returns>
         IJT808MsgIdFactory SetMap<TJT808Bodies>() where TJT808Bodies : JT808Bodies;
     }
 }

src/JT808.Protocol/Interfaces/IJT808MsgSNDistributed.cs

@@ -1,7 +1,15 @@
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// JT808分布式自增流水号
+    /// </summary>
     public interface IJT808MsgSNDistributed
     {
+        /// <summary>
+        /// 根据终端SIM号自增
+        /// </summary>
+        /// <param name="terminalPhoneNo"></param>
+        /// <returns></returns>
         ushort Increment(string terminalPhoneNo);
     }
 }

src/JT808.Protocol/Interfaces/IJT808SplitPackageStrategy.cs

@@ -10,6 +10,11 @@ namespace JT808.Protocol.Interfaces
     /// </summary>
     public interface IJT808SplitPackageStrategy
     {
+        /// <summary>
+        /// 分包处理器
+        /// </summary>
+        /// <param name="bigData"></param>
+        /// <returns></returns>
         IEnumerable<JT808SplitPackageProperty> Processor(ReadOnlySpan<byte> bigData);
     }
 }

src/JT808.Protocol/Interfaces/IJT808_0x0200_Custom_Factory.cs

@@ -5,9 +5,20 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 自定义0x0200附加信息工厂
+    /// </summary>
     public interface IJT808_0x0200_Custom_Factory: IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<byte, object> Map { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808_0x0200_CustomBody"></typeparam>
+        /// <returns></returns>
         IJT808_0x0200_Custom_Factory SetMap<TJT808_0x0200_CustomBody>() where TJT808_0x0200_CustomBody : JT808_0x0200_CustomBodyBase;
     }
 }

src/JT808.Protocol/Interfaces/IJT808_0x0200_Factory.cs

@@ -6,10 +6,20 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 0x0200附加信息工厂
+    /// </summary>
    public interface IJT808_0x0200_Factory: IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<byte, object> Map { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808_0x0200_Body"></typeparam>
+        /// <returns></returns>
         IJT808_0x0200_Factory SetMap<TJT808_0x0200_Body>() where TJT808_0x0200_Body : JT808_0x0200_BodyBase;
     }
 }

src/JT808.Protocol/Interfaces/IJT808_0x0900_Custom_Factory.cs

@@ -5,9 +5,20 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 自定义数据上行透传
+    /// </summary>
     public interface IJT808_0x0900_Custom_Factory : IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<byte, object> Map { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808_0x0900_BodyBase"></typeparam>
+        /// <returns></returns>
         IJT808_0x0900_Custom_Factory SetMap<TJT808_0x0900_BodyBase>() where TJT808_0x0900_BodyBase : JT808_0x0900_BodyBase;
     }
 }

src/JT808.Protocol/Interfaces/IJT808_0x8103_Custom_Factory.cs

@@ -5,9 +5,20 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 自定义设置终端参数消息工厂
+    /// </summary>
     public interface IJT808_0x8103_Custom_Factory : IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<uint, object> Map { get;}
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808_0x8103_CustomBody"></typeparam>
+        /// <returns></returns>
 
         IJT808_0x8103_Custom_Factory SetMap<TJT808_0x8103_CustomBody>() where TJT808_0x8103_CustomBody : JT808_0x8103_CustomBodyBase;
     }

src/JT808.Protocol/Interfaces/IJT808_0x8103_Factory.cs

@@ -6,9 +6,20 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 设置终端参数消息工厂
+    /// </summary>
     public interface IJT808_0x8103_Factory: IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<uint, object> Map { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808_0x8103_Body"></typeparam>
+        /// <returns></returns>
         IJT808_0x8103_Factory SetMap<TJT808_0x8103_Body>() where TJT808_0x8103_Body : JT808_0x8103_BodyBase;
     }
 }

src/JT808.Protocol/Interfaces/IJT808_0x8500_2019_Factory.cs

@@ -5,9 +5,20 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 车辆控制
+    /// </summary>
     public interface IJT808_0x8500_2019_Factory : IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<ushort, object> Map { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808_0x8500_ControlType"></typeparam>
+        /// <returns></returns>
         IJT808_0x8500_2019_Factory SetMap<TJT808_0x8500_ControlType>() where TJT808_0x8500_ControlType : JT808_0x8500_ControlType;
     }
 }

src/JT808.Protocol/Interfaces/IJT808_0x8900_Custom_Factory.cs

@@ -5,9 +5,20 @@ using System.Text;
 
 namespace JT808.Protocol.Interfaces
 {
+    /// <summary>
+    /// 自定义数据下行透传消息工厂
+    /// </summary>
     public interface IJT808_0x8900_Custom_Factory : IJT808ExternalRegister
     {
+        /// <summary>
+        /// 
+        /// </summary>
         IDictionary<byte, object> Map { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808_0x8900_BodyBase"></typeparam>
+        /// <returns></returns>
         IJT808_0x8900_Custom_Factory SetMap<TJT808_0x8900_BodyBase>() where TJT808_0x8900_BodyBase : JT808_0x8900_BodyBase;
     }
 }

src/JT808.Protocol/Internal/DefaultBuilder.cs

@@ -6,10 +6,24 @@ using System.Text;
 
 namespace JT808.Protocol.Internal
 {
+    /// <summary>
+    /// 默认JT808构造器
+    /// </summary>
     class DefaultBuilder : IJT808Builder
     {
+        /// <summary>
+        /// DI服务
+        /// </summary>
         public IServiceCollection Services { get; }
+        /// <summary>
+        /// JT808配置
+        /// </summary>
         public IJT808Config Config { get; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="services"></param>
+        /// <param name="config"></param>
         public DefaultBuilder(IServiceCollection services, IJT808Config config)
         {
             Services = services;

src/JT808.Protocol/Internal/DefaultGlobalConfig.cs

@@ -2,9 +2,19 @@
 
 namespace JT808.Protocol.Internal
 {
+    /// <summary>
+    /// 默认全局配置
+    /// </summary>
     class DefaultGlobalConfig : GlobalConfigBase
     {
+        /// <summary>
+        /// 配置Id
+        /// </summary>
         public override string ConfigId { get; protected set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="configId"></param>
         public DefaultGlobalConfig(string configId= "Default") 
         {
             ConfigId = configId;

src/JT808.Protocol/Internal/JT808_CarDVR_Up_Factory.cs

@@ -11,13 +11,22 @@ namespace JT808.Protocol.Interfaces
     /// </summary>
    public  class JT808_CarDVR_Up_Factory:IJT808_CarDVR_Up_Factory
     {
+        /// <summary>
+        /// 
+        /// </summary>
         public IDictionary<byte, object> Map { get; }
-
+        /// <summary>
+        /// 
+        /// </summary>
         public JT808_CarDVR_Up_Factory()
         {
             Map = new Dictionary<byte, object>();
             Register(Assembly.GetExecutingAssembly());
         }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="externalAssembly"></param>
         public void Register(Assembly externalAssembly)
         {
             var types = externalAssembly.GetTypes().Where(w => w.BaseType == typeof(JT808CarDVRUpBodies)).ToList();
@@ -35,7 +44,11 @@ namespace JT808.Protocol.Interfaces
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="TJT808CarDVRUpBodies"></typeparam>
+        /// <returns></returns>
         public IJT808_CarDVR_Up_Factory SetMap<TJT808CarDVRUpBodies>() where TJT808CarDVRUpBodies : JT808CarDVRUpBodies
         {
             Type type = typeof(TJT808CarDVRUpBodies);

src/JT808.Protocol/JT808ArrayPool.cs

@@ -2,6 +2,9 @@
 
 namespace JT808.Protocol
 {
+    /// <summary>
+    /// 内存池
+    /// </summary>
     internal static class JT808ArrayPool
     {
         private readonly static ArrayPool<byte> ArrayPool;
@@ -10,12 +13,20 @@ namespace JT808.Protocol
         {
             ArrayPool = ArrayPool<byte>.Create();
         }
-
+        /// <summary>
+        /// 申请
+        /// </summary>
+        /// <param name="minimumLength"></param>
+        /// <returns></returns>
         public static byte[] Rent(int minimumLength)
         {
             return ArrayPool.Rent(minimumLength);
         }
-
+        /// <summary>
+        /// 回收
+        /// </summary>
+        /// <param name="array"></param>
+        /// <param name="clearArray"></param>
         public static void Return(byte[] array, bool clearArray = false)
         {
             ArrayPool.Return(array, clearArray);

src/JT808.Protocol/JT808Bodies.cs

@@ -2,6 +2,9 @@
 
 namespace JT808.Protocol
 {
+    /// <summary>
+    /// JT808抽象数据体
+    /// </summary>
     public abstract class JT808Bodies: IJT808Description
     {
         /// <summary>
@@ -10,9 +13,13 @@ namespace JT808.Protocol
         /// 当数据体为空的时候，使用null作为空包感觉不适合，所以就算使用空包也需要new一下来表达意思。
         /// </summary>
         public virtual bool SkipSerialization { get; set; } = false;
-
+        /// <summary>
+        /// 消息Id
+        /// </summary>
         public abstract ushort MsgId { get;}
-
+        /// <summary>
+        /// 消息描述
+        /// </summary>
         public abstract string Description { get; }
     }
 }

src/JT808.Protocol/JT808CarDVRDownBodies.cs

@@ -1,4 +1,5 @@
-using JT808.Protocol.MessagePack;
+using JT808.Protocol.Interfaces;
+using JT808.Protocol.MessagePack;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -8,7 +9,7 @@ namespace JT808.Protocol
     /// <summary>
     /// 记录仪上行数据体
     /// </summary>
-    public abstract class JT808CarDVRDownBodies
+    public abstract class JT808CarDVRDownBodies : IJT808Description
     {
         /// <summary>
         /// 命令字
@@ -20,7 +21,9 @@ namespace JT808.Protocol
         /// 当数据体为空的时候，使用null作为空包感觉不适合，所以就算使用空包也需要new一下来表达意思。
         /// </summary>
         public virtual bool SkipSerialization { get; set; } = false;
-
+        /// <summary>
+        /// 消息描述
+        /// </summary>
         public abstract string Description { get; }
     }
 }

src/JT808.Protocol/JT808CarDVRDownPackage.cs

@@ -11,8 +11,14 @@ using System.Text.Json;
 
 namespace JT808.Protocol
 {
+    /// <summary>
+    /// 行车记录仪下行数据包
+    /// </summary>
     public  class JT808CarDVRDownPackage : IJT808_CarDVR_Down_Package,IJT808MessagePackFormatter<JT808CarDVRDownPackage>, IJT808Analyze
     {
+        /// <summary>
+        /// 头标识
+        /// </summary>
         public const ushort BeginFlag = 0x557A;
         /// <summary>
         /// 起始字头
@@ -38,7 +44,12 @@ namespace JT808.Protocol
         /// 校验字
         /// </summary>
         public byte CheckCode { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808CarDVRDownPackage value, IJT808Config config)
         {
             var currentPosition = writer.GetCurrentPosition();
@@ -57,7 +68,12 @@ namespace JT808.Protocol
             writer.WriteUInt16Return((ushort)(writer.GetCurrentPosition() -2-1- datalengthPosition), datalengthPosition);//此处-2：减去数据长度字段2位，-1：减去保留字长度
             writer.WriteCarDVRCheckCode(currentPosition);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808CarDVRDownPackage Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808CarDVRDownPackage value = new JT808CarDVRDownPackage();
@@ -84,7 +100,12 @@ namespace JT808.Protocol
             value.CheckCode = reader.ReadByte();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808CarDVRDownPackage value = new JT808CarDVRDownPackage();

src/JT808.Protocol/JT808CarDVRSerializer.cs

@@ -11,26 +11,54 @@ using System.Text.Json;
 
 namespace JT808.Protocol
 {
+    /// <summary>
+    /// JT19056序列化器
+    /// </summary>
     public  class JT808CarDVRSerializer
     {
+        /// <summary>
+        /// 
+        /// </summary>
         public readonly static JT808CarDVRUpPackage JT808CarDVRUpPackage = new JT808CarDVRUpPackage();
+        /// <summary>
+        /// 
+        /// </summary>
 
         public readonly static JT808CarDVRDownPackage JT808CarDVRDownPackage = new JT808CarDVRDownPackage();
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="jT808Config"></param>
         public JT808CarDVRSerializer(IJT808Config jT808Config)
         {
             this.jT808Config = jT808Config;
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         public JT808CarDVRSerializer():this(new DefaultGlobalConfig())
         {
 
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
         public string SerializerId => jT808Config.ConfigId;
+        /// <summary>
+        /// 
+        /// </summary>
 
         private readonly IJT808Config jT808Config;
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="package"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public byte[] Serialize(JT808CarDVRUpPackage package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -45,7 +73,13 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="package"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public ReadOnlySpan<byte> SerializeReadOnlySpan(JT808CarDVRUpPackage package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -60,7 +94,13 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="package"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public byte[] Serialize(JT808CarDVRDownPackage package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -75,7 +115,13 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="package"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public ReadOnlySpan<byte> SerializeReadOnlySpan(JT808CarDVRDownPackage package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -90,19 +136,36 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <returns></returns>
         public JT808CarDVRUpPackage UpDeserialize(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
             return JT808CarDVRUpPackage.Deserialize(ref jT808MessagePackReader, jT808Config);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <returns></returns>
         public JT808CarDVRDownPackage DownDeserialize(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
             return JT808CarDVRDownPackage.Deserialize(ref jT808MessagePackReader, jT808Config);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public byte [] Serialize<T>(T obj, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -118,7 +181,14 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public ReadOnlySpan<byte> SerializeReadOnlySpan<T>(T obj, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -134,21 +204,39 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <returns></returns>
         public T Deserialize<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
             var formatter = jT808Config.GetMessagePackFormatter<T>();
             return formatter.Deserialize(ref jT808MessagePackReader, jT808Config);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="type"></param>
+        /// <param name="version"></param>
+        /// <returns></returns>
         public dynamic Deserialize(ReadOnlySpan<byte> bytes, Type type, JT808Version version = JT808Version.JTT2013)
         {
             var formatter = jT808Config.GetMessagePackFormatterByType(type);
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
             return JT808MessagePackFormatterResolverExtensions.JT808DynamicDeserialize(formatter,ref jT808MessagePackReader, jT808Config);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
         public string UpAnalyze(ReadOnlySpan<byte> bytes,  JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
@@ -163,7 +251,13 @@ namespace JT808.Protocol
                 return value; 
             }   
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
         public string DownAnalyze(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
@@ -178,7 +272,14 @@ namespace JT808.Protocol
                 return value;
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
         public string Analyze<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
@@ -194,7 +295,13 @@ namespace JT808.Protocol
                 return value;
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
         public byte[] UpAnalyzeJsonBuffer(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
@@ -208,7 +315,13 @@ namespace JT808.Protocol
                 return memoryStream.ToArray();
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
         public byte[] DownAnalyzeJsonBuffer(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
@@ -222,7 +335,14 @@ namespace JT808.Protocol
                 return memoryStream.ToArray();
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
         public byte[] AnalyzeJsonBuffer<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
         {
             JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);

src/JT808.Protocol/JT808CarDVRUpBodies.cs

@@ -1,4 +1,5 @@
-using JT808.Protocol.MessagePack;
+using JT808.Protocol.Interfaces;
+using JT808.Protocol.MessagePack;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -8,7 +9,7 @@ namespace JT808.Protocol
     /// <summary>
     /// 记录仪上行数据体
     /// </summary>
-    public abstract class JT808CarDVRUpBodies
+    public abstract class JT808CarDVRUpBodies: IJT808Description
     {
         /// <summary>
         /// 命令字
@@ -20,7 +21,9 @@ namespace JT808.Protocol
         /// 当数据体为空的时候，使用null作为空包感觉不适合，所以就算使用空包也需要new一下来表达意思。
         /// </summary>
         public virtual bool SkipSerialization { get; set; } = false;
-
+        /// <summary>
+        /// 消息描述
+        /// </summary>
         public abstract string Description { get; }
     }
 }

src/JT808.Protocol/JT808CarDVRUpPackage.cs

@@ -16,6 +16,9 @@ namespace JT808.Protocol
     /// </summary>
     public class JT808CarDVRUpPackage : IJT808_CarDVR_Up_Package,IJT808MessagePackFormatter<JT808CarDVRUpPackage>, IJT808Analyze
     {
+        /// <summary>
+        /// 起始字头
+        /// </summary>
         public const ushort BeginFlag = 0x557A;
         /// <summary>
         /// 起始字头
@@ -41,7 +44,12 @@ namespace JT808.Protocol
         /// 校验字
         /// </summary>
         public byte CheckCode { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808CarDVRUpPackage value = new JT808CarDVRUpPackage();
@@ -77,7 +85,12 @@ namespace JT808.Protocol
             }
             writer.WriteEndObject();
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808CarDVRUpPackage Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808CarDVRUpPackage value = new JT808CarDVRUpPackage();
@@ -104,7 +117,12 @@ namespace JT808.Protocol
             value.CheckCode = reader.ReadByte();
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808CarDVRUpPackage value, IJT808Config config)
         {
             var currentPosition = writer.GetCurrentPosition();

src/JT808.Protocol/JT808Constants.cs

@@ -4,6 +4,9 @@ using System.Text;
 
 namespace JT808.Protocol
 {
+    /// <summary>
+    /// JT808常量
+    /// </summary>
     public static class JT808Constants
     {
         static JT808Constants()
@@ -15,22 +18,70 @@ namespace JT808.Protocol
         /// 日期限制于2000年
         /// </summary>
         public const int DateLimitYear = 2000;
+        /// <summary>
+        /// 
+        /// </summary>
         public static readonly DateTime UTCBaseTime = new DateTime(1970, 1, 1);
+        /// <summary>
+        /// 
+        /// </summary>
         public static Encoding Encoding { get;}
+        /// <summary>
+        /// JT808_0x0200_0x01
+        /// </summary>
 
         public const byte JT808_0x0200_0x01 = 0x01;
+        /// <summary>
+        /// JT808_0x0200_0x02
+        /// </summary>
         public const byte JT808_0x0200_0x02 = 0x02;
+        /// <summary>
+        /// JT808_0x0200_0x03
+        /// </summary>
         public const byte JT808_0x0200_0x03 = 0x03;
+        /// <summary>
+        /// JT808_0x0200_0x04
+        /// </summary>
         public const byte JT808_0x0200_0x04 = 0x04;
+        /// <summary>
+        /// JT808_0x0200_0x05
+        /// </summary>
         public const byte JT808_0x0200_0x05 = 0x05;
+        /// <summary>
+        /// JT808_0x0200_0x06
+        /// </summary>
         public const byte JT808_0x0200_0x06 = 0x06;
+        /// <summary>
+        /// JT808_0x0200_0x11
+        /// </summary>
         public const byte JT808_0x0200_0x11 = 0x11;
+        /// <summary>
+        /// JT808_0x0200_0x12
+        /// </summary>
         public const byte JT808_0x0200_0x12 = 0x12;
+        /// <summary>
+        /// JT808_0x0200_0x13
+        /// </summary>
         public const byte JT808_0x0200_0x13 = 0x13;
+        /// <summary>
+        /// JT808_0x0200_0x25
+        /// </summary>
         public const byte JT808_0x0200_0x25 = 0x25;
+        /// <summary>
+        /// JT808_0x0200_0x2A
+        /// </summary>
         public const byte JT808_0x0200_0x2A = 0x2A;
+        /// <summary>
+        /// JT808_0x0200_0x2B
+        /// </summary>
         public const byte JT808_0x0200_0x2B = 0x2B;
+        /// <summary>
+        /// JT808_0x0200_0x30
+        /// </summary>
         public const byte JT808_0x0200_0x30 = 0x30;
+        /// <summary>
+        /// JT808_0x0200_0x31
+        /// </summary>
         public const byte JT808_0x0200_0x31 = 0x31;
         /// <summary>
         /// 终端心跳发送间隔，单位为秒（s）

src/JT808.Protocol/JT808Header.cs

@@ -49,7 +49,12 @@ namespace JT808.Protocol
         /// 报序号 从1开始
         /// </summary>
         public ushort PackageIndex { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808Header Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808Header jT808Header = new JT808Header();
@@ -82,7 +87,12 @@ namespace JT808.Protocol
             }
             return jT808Header;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808Header value, IJT808Config config)
         {
             // 1.消息ID

src/JT808.Protocol/JT808HeaderMessageBodyProperty.cs

@@ -5,8 +5,18 @@ using System;
 
 namespace JT808.Protocol
 {
+    /// <summary>
+    /// 头部消息体属性
+    /// </summary>
     public class JT808HeaderMessageBodyProperty
     {
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="dataLength"></param>
+        /// <param name="isPackage"></param>
+        /// <param name="versionFlag"></param>
+        /// <param name="jT808EncryptMethod"></param>
         public JT808HeaderMessageBodyProperty(int dataLength,bool isPackage, bool versionFlag= false, JT808EncryptMethod jT808EncryptMethod= JT808EncryptMethod.None)
         {
             IsPackage = isPackage;
@@ -14,7 +24,12 @@ namespace JT808.Protocol
             DataLength = dataLength;
             VersionFlag = versionFlag;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="isPackage"></param>
+        /// <param name="versionFlag"></param>
+        /// <param name="jT808EncryptMethod"></param>
         public JT808HeaderMessageBodyProperty(bool isPackage, bool versionFlag, JT808EncryptMethod jT808EncryptMethod = JT808EncryptMethod.None)
         {
             IsPackage = isPackage;
@@ -22,7 +37,11 @@ namespace JT808.Protocol
             DataLength = 0;
             VersionFlag = versionFlag;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="versionFlag"></param>
+        /// <param name="jT808EncryptMethod"></param>
         public JT808HeaderMessageBodyProperty(bool versionFlag, JT808EncryptMethod jT808EncryptMethod = JT808EncryptMethod.None)
         {
             IsPackage = false;
@@ -30,7 +49,14 @@ namespace JT808.Protocol
             DataLength = 0;
             VersionFlag = versionFlag;
         }
+        /// <summary>
+        /// 
+        /// </summary>
         public JT808HeaderMessageBodyProperty(){}
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="value"></param>
         public JT808HeaderMessageBodyProperty(ushort value)
         {
             VersionFlag = (value >> 14 & 0x01) == 1;
@@ -70,6 +96,10 @@ namespace JT808.Protocol
         /// 消息体长度
         /// </summary>
         public int DataLength { get; set; } = 0;
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
         public ushort Wrap()
         {
             //  1.是否分包

src/JT808.Protocol/JT808HeaderPackage.cs

@@ -64,7 +64,11 @@ namespace JT808.Protocol
         /// 原数据
         /// </summary>
         public byte[] OriginalData { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
         public  JT808HeaderPackage(ref JT808MessagePackReader reader, IJT808Config config)
         {
             // 1. 验证校验和

src/JT808.Protocol/JT808Package.cs

@@ -78,7 +78,12 @@ namespace JT808.Protocol
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808Package Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             // 1. 验证校验和
@@ -164,7 +169,12 @@ namespace JT808.Protocol
             // ---------------解包完成--------------
             return jT808Package;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808Package value, IJT808Config config)
         {
             // ---------------开始组包--------------
@@ -243,7 +253,12 @@ namespace JT808.Protocol
             writer.WriteEncode();
             // ---------------组包结束--------------
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             // ---------------开始解析对象--------------

src/JT808.Protocol/JT808Serializer.cs

@@ -40,7 +40,13 @@ namespace JT808.Protocol
         public string SerializerId => jT808Config.ConfigId;
 
         private readonly IJT808Config jT808Config;
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="package"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public byte[] Serialize(JT808Package package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -55,7 +61,13 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="package"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public ReadOnlySpan<byte> SerializeReadOnlySpan(JT808Package package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -70,7 +82,13 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public JT808Package Deserialize(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -85,7 +103,14 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public byte [] Serialize<T>(T obj, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -101,7 +126,14 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public ReadOnlySpan<byte> SerializeReadOnlySpan<T>(T obj, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -117,7 +149,14 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public T Deserialize<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -134,7 +173,11 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
         private static bool CheckPackageType(Type type)
         {
             return type == typeof(JT808Package) || type == typeof(JT808HeaderPackage);
@@ -145,6 +188,8 @@ namespace JT808.Protocol
         /// 根据头部的消息Id进行分发处理，可以防止小部分性能损耗。
         /// </summary>
         /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
         /// <returns></returns>
         public JT808HeaderPackage HeaderDeserialize(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
@@ -160,6 +205,14 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="type"></param>
+        /// <param name="version"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public dynamic Deserialize(ReadOnlySpan<byte> bytes, Type type, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -176,7 +229,14 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public string Analyze(ReadOnlySpan<byte> bytes,  JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default, int minBufferSize = 8096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -198,7 +258,15 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }       
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public string Analyze<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default, int minBufferSize = 8096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -303,7 +371,14 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public byte[] AnalyzeJsonBuffer(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default, int minBufferSize = 8096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
@@ -324,7 +399,15 @@ namespace JT808.Protocol
                 JT808ArrayPool.Return(buffer);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="bytes"></param>
+        /// <param name="version"></param>
+        /// <param name="options"></param>
+        /// <param name="minBufferSize"></param>
+        /// <returns></returns>
         public byte[] AnalyzeJsonBuffer<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default, int minBufferSize = 8096)
         {
             byte[] buffer = JT808ArrayPool.Rent(minBufferSize);

src/JT808.Protocol/MessageBody/JT808_0x0704.cs

@@ -41,7 +41,13 @@ namespace JT808.Protocol.MessageBody
         /// </summary>
         public enum BatchLocationType : byte
         {
+            /// <summary>
+            /// 正常位置批量汇报
+            /// </summary>
             正常位置批量汇报 = 0x00,
+            /// <summary>
+            /// 盲区补报
+            /// </summary>
             盲区补报 = 0x01
         }
         /// <summary>

src/JT808.Protocol/MessageBody/JT808_0x8004.cs

@@ -20,7 +20,9 @@ namespace JT808.Protocol.MessageBody
         /// 查询服务器时间应答
         /// </summary>
         public override string Description => "查询服务器时间应答";
-
+        /// <summary>
+        /// 服务器时间
+        /// </summary>
         public DateTime Time { get; set; } = DateTime.Now;
         /// <summary>
         /// 

src/JT808.Protocol/MessageBody/JT808_0x8103_0x0018.cs

@@ -10,8 +10,8 @@ namespace JT808.Protocol.MessageBody
 {
     /// <summary>
     /// 服务器 TCP 端口
+    /// 2019版本已作为保留
     /// </summary>
-    [Obsolete("2019版本已作为保留")]
     public class JT808_0x8103_0x0018 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter<JT808_0x8103_0x0018>, IJT808_2019_Version, IJT808Analyze
     {
         /// <summary>

src/JT808.Protocol/MessageBody/JT808_0x8103_0x0101.cs

@@ -12,9 +12,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8103_0x0101 : JT808_0x8103_BodyBase, IJT808MessagePackFormatter<JT808_0x8103_0x0101>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x0101
+        /// </summary>
         public override uint ParamId { get; set; } = 0x0101;
         /// <summary>
-        /// 数据 长度
+        /// 数据长度
+        /// 2 byte
         /// </summary>
         public override byte ParamLength { get; set; } = 2;
         /// <summary>

src/JT808.Protocol/MessageBody/JT808_0x8103_0x0110.cs

@@ -48,7 +48,12 @@ namespace JT808.Protocol.MessageBody
         /// bit28-bit0 表示 CAN 总线 ID。
         /// </summary>
         public long BusId { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8103_0x0110 jT808_0x8103_0x0110 = new JT808_0x8103_0x0110();
@@ -71,7 +76,12 @@ namespace JT808.Protocol.MessageBody
             writer.WriteNumber($"[{ jT808_0x8103_0x0110.BusId.ReadNumber()}]CAN 总线 ID", jT808_0x8103_0x0110.BusId);
             writer.WriteEndObject();
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8103_0x0110 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8103_0x0110 jT808_0x8103_0x0110 = new JT808_0x8103_0x0110();
@@ -85,7 +95,12 @@ namespace JT808.Protocol.MessageBody
             jT808_0x8103_0x0110.BusId = temp & 0x01FFFFFF;
             return jT808_0x8103_0x0110;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8103_0x0110 value, IJT808Config config)
         {
             writer.WriteUInt32(value.ParamId);

src/JT808.Protocol/MessageBody/JT808_0x8600.cs

@@ -18,7 +18,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8600 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8600>, IJT808Analyze, IJT808_2019_Version
     {
+        /// <summary>
+        /// 0x8600
+        /// </summary>
         public override ushort MsgId { get; } = 0x8600;
+        /// <summary>
+        /// 设置圆形区域
+        /// </summary>
         public override string Description => "设置圆形区域";
         /// <summary>
         /// 设置属性
@@ -33,7 +39,12 @@ namespace JT808.Protocol.MessageBody
         /// 区域项
         /// </summary>
         public List<JT808CircleAreaProperty> AreaItems { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8600 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8600 jT808_0X8600 = new JT808_0x8600();
@@ -74,7 +85,12 @@ namespace JT808.Protocol.MessageBody
             }
             return jT808_0X8600;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8600 value, IJT808Config config)
         {
             writer.WriteByte(value.SettingAreaProperty);
@@ -126,7 +142,12 @@ namespace JT808.Protocol.MessageBody
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8600 value = new JT808_0x8600();

src/JT808.Protocol/MessageBody/JT808_0x8601.cs

@@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8601 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8601>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8601
+        /// </summary>
         public override ushort MsgId { get; } = 0x8601;
+        /// <summary>
+        /// 删除圆形区域
+        /// </summary>
         public override string Description => "删除圆形区域";
         /// <summary>
         /// 区域数
@@ -24,7 +30,12 @@ namespace JT808.Protocol.MessageBody
         /// 区域ID集合
         /// </summary>
         public List<uint> AreaIds { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8601 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8601 jT808_0X8601 = new JT808_0x8601();
@@ -36,7 +47,12 @@ namespace JT808.Protocol.MessageBody
             }
             return jT808_0X8601;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8601 value, IJT808Config config)
         {
             if (value.AreaIds != null)
@@ -48,7 +64,12 @@ namespace JT808.Protocol.MessageBody
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8601 value = new JT808_0x8601();

src/JT808.Protocol/MessageBody/JT808_0x8602.cs

@@ -17,7 +17,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8602 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8602>, IJT808Analyze, IJT808_2019_Version
     {
+        /// <summary>
+        /// 0x8602
+        /// </summary>
         public override ushort MsgId { get; } = 0x8602;
+        /// <summary>
+        /// 设置矩形区域
+        /// </summary>
         public override string Description => "设置矩形区域";
         /// <summary>
         /// 设置属性
@@ -32,7 +38,12 @@ namespace JT808.Protocol.MessageBody
         /// 区域项
         /// </summary>
         public List<JT808RectangleAreaProperty> AreaItems { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8602 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8602 jT808_0X8602 = new JT808_0x8602();
@@ -74,7 +85,12 @@ namespace JT808.Protocol.MessageBody
             }
             return jT808_0X8602;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8602 value, IJT808Config config)
         {
             writer.WriteByte(value.SettingAreaProperty);
@@ -127,7 +143,12 @@ namespace JT808.Protocol.MessageBody
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8602 value = new JT808_0x8602();

src/JT808.Protocol/MessageBody/JT808_0x8603.cs

@@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8603 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8603>, IJT808Analyze
     {
+        /// <summary>
+        /// 
+        /// </summary>
         public override ushort MsgId { get; } = 0x8603;
+        /// <summary>
+        /// 
+        /// </summary>
         public override string Description => "删除矩形区域";
         /// <summary>
         /// 区域数
@@ -24,7 +30,12 @@ namespace JT808.Protocol.MessageBody
         /// 区域ID集合
         /// </summary>
         public List<uint> AreaIds { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8603 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8603 jT808_0X8603 = new JT808_0x8603();
@@ -36,7 +47,12 @@ namespace JT808.Protocol.MessageBody
             }
             return jT808_0X8603;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8603 value, IJT808Config config)
         {
             if (value.AreaIds != null)
@@ -48,7 +64,12 @@ namespace JT808.Protocol.MessageBody
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8603 value = new JT808_0x8603();

src/JT808.Protocol/MessageBody/JT808_0x8604.cs

@@ -17,7 +17,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8604 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8604>, IJT808Analyze, IJT808_2019_Version
     {
+        /// <summary>
+        /// 0x8604
+        /// </summary>
         public override ushort MsgId { get; } = 0x8604;
+        /// <summary>
+        /// 设置多边形区域
+        /// </summary>
         public override string Description => "设置多边形区域";
         /// <summary>
         /// 区域 ID
@@ -71,7 +77,12 @@ namespace JT808.Protocol.MessageBody
         /// 2019版本
         /// </summary>
         public string AreaName { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8604 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8604 jT808_0X8604 = new JT808_0x8604();
@@ -110,7 +121,12 @@ namespace JT808.Protocol.MessageBody
             }
             return jT808_0X8604;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8604 value, IJT808Config config)
         {
             writer.WriteUInt32(value.AreaId);
@@ -160,7 +176,12 @@ namespace JT808.Protocol.MessageBody
                 writer.WriteUInt16Return((ushort)(writer.GetCurrentPosition() - AreaNameLengthPosition - 2), AreaNameLengthPosition);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8604 value = new JT808_0x8604();

src/JT808.Protocol/MessageBody/JT808_0x8605.cs

@@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8605 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8605>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8605
+        /// </summary>
         public override ushort MsgId { get; } = 0x8605;
+        /// <summary>
+        /// 删除多边形区域
+        /// </summary>
         public override string Description => "删除多边形区域";
         /// <summary>
         /// 区域数
@@ -24,6 +30,12 @@ namespace JT808.Protocol.MessageBody
         /// 区域ID集合
         /// </summary>
         public List<uint> AreaIds { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8605 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8605 jT808_0X8605 = new JT808_0x8605();
@@ -35,7 +47,12 @@ namespace JT808.Protocol.MessageBody
             }
             return jT808_0X8605;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8605 value, IJT808Config config)
         {
             if (value.AreaIds != null)
@@ -47,7 +64,12 @@ namespace JT808.Protocol.MessageBody
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8605 value = new JT808_0x8605();

src/JT808.Protocol/MessageBody/JT808_0x8606.cs

@@ -17,7 +17,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8606 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8606>, IJT808Analyze, IJT808_2019_Version
     {
+        /// <summary>
+        /// 0x8606
+        /// </summary>
         public override ushort MsgId { get; } = 0x8606;
+        /// <summary>
+        /// 设置路线
+        /// </summary>
         public override string Description => "设置路线";
         /// <summary>
         /// 路线 ID
@@ -54,7 +60,12 @@ namespace JT808.Protocol.MessageBody
         /// 路线名称
         /// </summary>
         public string RouteName { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8606 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8606 jT808_0X8606 = new JT808_0x8606();
@@ -102,7 +113,12 @@ namespace JT808.Protocol.MessageBody
             }
             return jT808_0X8606;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8606 value, IJT808Config config)
         {
             writer.WriteUInt32(value.RouteId);
@@ -161,7 +177,12 @@ namespace JT808.Protocol.MessageBody
                 writer.WriteUInt16Return((ushort)(writer.GetCurrentPosition() - RouteNameLengthPosition - 2), RouteNameLengthPosition);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8606 value = new JT808_0x8606();

src/JT808.Protocol/MessageBody/JT808_0x8607.cs

@@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8607 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8607>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8607
+        /// </summary>
         public override ushort MsgId { get; } = 0x8607;
+        /// <summary>
+        /// 删除路线
+        /// </summary>
         public override string Description => "删除路线";
         /// <summary>
         /// 区域数
@@ -24,7 +30,12 @@ namespace JT808.Protocol.MessageBody
         /// 区域ID集合
         /// </summary>
         public List<uint> AreaIds { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8607 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8607 jT808_0X8607 = new JT808_0x8607();
@@ -36,7 +47,12 @@ namespace JT808.Protocol.MessageBody
             }
             return jT808_0X8607;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8607 value, IJT808Config config)
         {
             if (value.AreaIds != null)
@@ -48,7 +64,12 @@ namespace JT808.Protocol.MessageBody
                 }
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8607 value = new JT808_0x8607();

src/JT808.Protocol/MessageBody/JT808_0x8608.cs

@@ -14,7 +14,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8608 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8608>, IJT808Analyze, IJT808_2019_Version
     {
+        /// <summary>
+        /// 0x8608
+        /// </summary>
         public override ushort MsgId { get; } = 0x8608;
+        /// <summary>
+        /// 查询区域或线路数据
+        /// </summary>
         public override string Description => "查询区域或线路数据";
         /// <summary>
         /// 查询类型
@@ -30,7 +36,12 @@ namespace JT808.Protocol.MessageBody
         /// 查询的区域或线路的ID
         /// </summary>
         public List<uint> Ids { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8608 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8608 value = new JT808_0x8608();
@@ -46,7 +57,12 @@ namespace JT808.Protocol.MessageBody
             }
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8608 value, IJT808Config config)
         {
             writer.WriteByte(value.QueryType);
@@ -63,7 +79,12 @@ namespace JT808.Protocol.MessageBody
                 writer.WriteUInt32(0);
             }
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8608 value = new JT808_0x8608();

src/JT808.Protocol/MessageBody/JT808_0x8700.cs

@@ -10,18 +10,33 @@ using System.Text.Json;
 
 namespace JT808.Protocol.MessageBody
 {
+    /// <summary>
+    /// 行驶记录数据采集命令
+    /// </summary>
     public class JT808_0x8700 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8700>, IJT808_2019_Version, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8700
+        /// </summary>
         public override ushort MsgId => 0x8700;
-
+        /// <summary>
+        /// 行驶记录数据采集命令
+        /// </summary>
         public override string Description => "行驶记录数据采集命令";
         /// <summary>
-        /// 
+        /// 命令Id
         /// </summary>
         public byte CommandId { get; set; }
-
+        /// <summary>
+        /// 行车记录仪下行数据包
+        /// </summary>
         public JT808CarDVRDownPackage JT808CarDVRDownPackage { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8700 value = new JT808_0x8700();
@@ -33,7 +48,12 @@ namespace JT808.Protocol.MessageBody
             writer.WriteEndObject();
             writer.WriteEndObject();
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8700 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8700 value = new JT808_0x8700();
@@ -41,7 +61,12 @@ namespace JT808.Protocol.MessageBody
             value.JT808CarDVRDownPackage = JT808CarDVRSerializer.JT808CarDVRDownPackage.Deserialize(ref reader, config);
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8700 value, IJT808Config config)
         {
             writer.WriteByte(value.CommandId);

src/JT808.Protocol/MessageBody/JT808_0x8701.cs

@@ -15,16 +15,28 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8701: JT808Bodies, IJT808MessagePackFormatter<JT808_0x8701>, IJT808_2019_Version, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8701
+        /// </summary>
         public override ushort MsgId => 0x8701;
-
+        /// <summary>
+        /// 行驶记录参数下传命令
+        /// </summary>
         public override string Description => "行驶记录参数下传命令";
         /// <summary>
-        /// 
+        /// 命令Id
         /// </summary>
         public byte CommandId { get; set; }
-
+        /// <summary>
+        /// 行驶记录参数下传命令包
+        /// </summary>
         public JT808CarDVRDownPackage JT808CarDVRDownPackage { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8701 value = new JT808_0x8701();
@@ -36,7 +48,12 @@ namespace JT808.Protocol.MessageBody
             writer.WriteEndObject();
             writer.WriteEndObject();
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8701 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8701 value = new JT808_0x8701();
@@ -44,7 +61,12 @@ namespace JT808.Protocol.MessageBody
             value.JT808CarDVRDownPackage = JT808CarDVRSerializer.JT808CarDVRDownPackage.Deserialize(ref reader, config);
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8701 value, IJT808Config config)
         {
             writer.WriteByte(value.CommandId);

src/JT808.Protocol/MessageBody/JT808_0x8702.cs

@@ -5,7 +5,13 @@
     /// </summary>
     public class JT808_0x8702 : JT808Bodies
     {
+        /// <summary>
+        /// 0x8702
+        /// </summary>
         public override ushort MsgId { get; } = 0x8702;
+        /// <summary>
+        /// 上报驾驶员身份信息请求
+        /// </summary>
         public override string Description => "上报驾驶员身份信息请求";
         /// <summary>
         /// 跳过数据体序列化

src/JT808.Protocol/MessageBody/JT808_0x8800.cs

@@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8800 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8800>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8800
+        /// </summary>
         public override ushort MsgId { get; } = 0x8800;
+        /// <summary>
+        /// 多媒体数据上传应答
+        /// </summary>
         public override string Description => "多媒体数据上传应答";
         /// <summary>
         /// 多媒体ID
@@ -28,7 +34,12 @@ namespace JT808.Protocol.MessageBody
         /// 重传包序号顺序排列，如“包 ID1 包 ID2......包 IDn”。
         /// </summary>
         public byte[] RetransmitPackageIds { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8800 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8800 jT808_0X8800 = new JT808_0x8800();
@@ -37,14 +48,24 @@ namespace JT808.Protocol.MessageBody
             jT808_0X8800.RetransmitPackageIds = reader.ReadArray(jT808_0X8800.RetransmitPackageCount * 2).ToArray();
             return jT808_0X8800;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8800 value, IJT808Config config)
         {
             writer.WriteUInt32(value.MultimediaId);
             writer.WriteByte((byte)(value.RetransmitPackageIds.Length / 2));
             writer.WriteArray(value.RetransmitPackageIds);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8800 value = new JT808_0x8800();

src/JT808.Protocol/MessageBody/JT808_0x8801.cs

@@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8801 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8801>, IJT808Analyze, IJT808_2019_Version
     {
+        /// <summary>
+        /// 0x8801
+        /// </summary>
         public override ushort MsgId { get; } = 0x8801;
+        /// <summary>
+        /// 摄像头立即拍摄命令
+        /// </summary>
         public override string Description => "摄像头立即拍摄命令";
         /// <summary>
         /// 通道 ID
@@ -64,7 +70,12 @@ namespace JT808.Protocol.MessageBody
         /// 0-255
         /// </summary>
         public byte Chroma { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8801 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8801 jT808_0X8801 = new JT808_0x8801();
@@ -80,7 +91,12 @@ namespace JT808.Protocol.MessageBody
             jT808_0X8801.Chroma = reader.ReadByte();
             return jT808_0X8801;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8801 value, IJT808Config config)
         {
             writer.WriteByte(value.ChannelId);
@@ -94,7 +110,12 @@ namespace JT808.Protocol.MessageBody
             writer.WriteByte(value.Saturability);
             writer.WriteByte(value.Chroma);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8801 value = new JT808_0x8801();

src/JT808.Protocol/MessageBody/JT808_0x8802.cs

@@ -14,7 +14,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8802 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8802>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8802
+        /// </summary>
         public override ushort MsgId { get; } = 0x8802;
+        /// <summary>
+        /// 存储多媒体数据检索
+        /// </summary>
         public override string Description => "存储多媒体数据检索";
         /// <summary>
         /// 多媒体类型
@@ -41,7 +47,12 @@ namespace JT808.Protocol.MessageBody
         /// YY-MM-DD-hh-mm-ss
         /// </summary>
         public DateTime EndTime { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8802 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8802 jT808_0X8802 = new JT808_0x8802();
@@ -52,7 +63,12 @@ namespace JT808.Protocol.MessageBody
             jT808_0X8802.EndTime = reader.ReadDateTime6();
             return jT808_0X8802;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8802 value, IJT808Config config)
         {
             writer.WriteByte(value.MultimediaType);
@@ -61,7 +77,12 @@ namespace JT808.Protocol.MessageBody
             writer.WriteDateTime6(value.StartTime);
             writer.WriteDateTime6(value.EndTime);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8802 value = new JT808_0x8802();

src/JT808.Protocol/MessageBody/JT808_0x8803.cs

@@ -14,7 +14,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8803 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8803>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8803
+        /// </summary>
         public override ushort MsgId { get; } = 0x8803;
+        /// <summary>
+        /// 存储多媒体数据上传命令
+        /// </summary>
         public override string Description => "存储多媒体数据上传命令";
         /// <summary>
         /// 多媒体类型 
@@ -47,7 +53,12 @@ namespace JT808.Protocol.MessageBody
         /// <see cref="JT808.Protocol.Enums.JT808MultimediaDeleted"/>
         /// </summary>
         public byte MultimediaDeleted { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8803 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8803 jT808_0X8803 = new JT808_0x8803();
@@ -59,7 +70,12 @@ namespace JT808.Protocol.MessageBody
             jT808_0X8803.MultimediaDeleted = reader.ReadByte();
             return jT808_0X8803;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8803 value, IJT808Config config)
         {
             writer.WriteByte(value.MultimediaType);
@@ -69,7 +85,12 @@ namespace JT808.Protocol.MessageBody
             writer.WriteDateTime6(value.EndTime);
             writer.WriteByte(value.MultimediaDeleted);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8803 value = new JT808_0x8803();

src/JT808.Protocol/MessageBody/JT808_0x8804.cs

@@ -12,7 +12,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8804 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8804>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8804
+        /// </summary>
         public override ushort MsgId { get; } = 0x8804;
+        /// <summary>
+        /// 录音开始命令
+        /// </summary>
         public override string Description => "录音开始命令";
         /// <summary>
         /// 录音命令
@@ -33,7 +39,12 @@ namespace JT808.Protocol.MessageBody
         /// 0：8K；1：11K；2：23K；3：32K；其他保留
         /// </summary>
         public byte AudioSampleRate { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8804 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8804 jT808_0X8804 = new JT808_0x8804();
@@ -43,6 +54,12 @@ namespace JT808.Protocol.MessageBody
             jT808_0X8804.AudioSampleRate = reader.ReadByte();
             return jT808_0X8804;
         }
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8804 value, IJT808Config config)
         {
             writer.WriteByte((byte)value.RecordCmd);
@@ -50,7 +67,12 @@ namespace JT808.Protocol.MessageBody
             writer.WriteByte((byte)value.RecordSave);
             writer.WriteByte(value.AudioSampleRate);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8804 value = new JT808_0x8804();

src/JT808.Protocol/MessageBody/JT808_0x8805.cs

@@ -12,7 +12,14 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8805 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8805>, IJT808Analyze, IJT808_2019_Version
     {
+        /// <summary>
+        /// 0x8805
+        /// </summary>
         public override ushort MsgId { get; } = 0x8805;
+
+        /// <summary>
+        /// 单条存储多媒体数据检索上传命令
+        /// </summary>
         public override string Description => "单条存储多媒体数据检索上传命令";
         /// <summary>
         /// 多媒体ID
@@ -23,7 +30,12 @@ namespace JT808.Protocol.MessageBody
         /// <see cref="JT808.Protocol.Enums.JT808MultimediaDeleted"/>
         /// </summary>
         public byte MultimediaDeleted { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8805 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8805 jT808_0X8805 = new JT808_0x8805();
@@ -31,13 +43,23 @@ namespace JT808.Protocol.MessageBody
             jT808_0X8805.MultimediaDeleted = reader.ReadByte();
             return jT808_0X8805;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8805 value, IJT808Config config)
         {
             writer.WriteUInt32(value.MultimediaId);
             writer.WriteByte(value.MultimediaDeleted);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8805 value = new JT808_0x8805();

src/JT808.Protocol/MessageBody/JT808_0x8900.cs

@@ -11,7 +11,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8900 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8900>, IJT808Analyze, IJT808_2019_Version
     {
+        /// <summary>
+        /// 0x8900
+        /// </summary>
         public override ushort MsgId { get; } = 0x8900;
+        /// <summary>
+        /// 数据下行透传
+        /// </summary>
         public override string Description => "数据下行透传";
         /// <summary>
         /// 透传消息类型
@@ -28,7 +34,12 @@ namespace JT808.Protocol.MessageBody
         /// 透传消息内容
         /// </summary>
         public JT808_0x8900_BodyBase JT808_0X8900_BodyBase { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8900 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8900 value = new JT808_0x8900();
@@ -43,13 +54,23 @@ namespace JT808.Protocol.MessageBody
             }
             return value;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8900 value, IJT808Config config)
         {
             writer.WriteByte(value.PassthroughType);
             JT808MessagePackFormatterResolverExtensions.JT808DynamicSerialize(value.JT808_0X8900_BodyBase, ref writer, value.JT808_0X8900_BodyBase, config);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8900 value = new JT808_0x8900();

src/JT808.Protocol/MessageBody/JT808_0x8A00.cs

@@ -13,7 +13,13 @@ namespace JT808.Protocol.MessageBody
     /// </summary>
     public class JT808_0x8A00 : JT808Bodies, IJT808MessagePackFormatter<JT808_0x8A00>, IJT808Analyze
     {
+        /// <summary>
+        /// 0x8A00
+        /// </summary>
         public override ushort MsgId { get; } = 0x8A00;
+        /// <summary>
+        /// 平台RSA公钥
+        /// </summary>
         public override string Description => "平台RSA公钥";
         /// <summary>
         /// e
@@ -25,7 +31,12 @@ namespace JT808.Protocol.MessageBody
         /// RSA 公钥{e,n}中的 n
         /// </summary>
         public byte[] N { get; set; }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="config"></param>
+        /// <returns></returns>
         public JT808_0x8A00 Deserialize(ref JT808MessagePackReader reader, IJT808Config config)
         {
             JT808_0x8A00 jT808_0X8A00 = new JT808_0x8A00();
@@ -33,7 +44,12 @@ namespace JT808.Protocol.MessageBody
             jT808_0X8A00.N = reader.ReadArray(128).ToArray();
             return jT808_0X8A00;
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        /// <param name="config"></param>
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8A00 value, IJT808Config config)
         {
             writer.WriteUInt32(value.E);
@@ -43,7 +59,12 @@ namespace JT808.Protocol.MessageBody
             }
             writer.WriteArray(value.N);
         }
-
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="writer"></param>
+        /// <param name="config"></param>
         public void Analyze(ref JT808MessagePackReader reader, Utf8JsonWriter writer, IJT808Config config)
         {
             JT808_0x8A00 jT808_0X8A00 = new JT808_0x8A00();